前情提要
在上一篇中 ， 我们了解到了 ， 创建一个Java对象的几个步骤：
第一，
findClass找到需要创建对象的类（全类名）
第二，得到构造方法的ID，构造方法名称，统一使用<init>
第三，使用NewObject创建Java对象
当创建了这个类的对象之后 ， 我们就可以使用这个类里面所提供的方法了 ， 那么我们就可以在C中使用Java中其他对象的方法了 。
数组引用的处理
在Java中 ， 使用new关键字创建对象 ， 创建之后我们就可以随意使用这个对象 ， 我们无需关心这个对象是什么时候被回收的 ， 对象的回收已经托管到了JVM的GC ， 由GC来帮我们回收无引用的对象 ， 那么，我们使用JNI技术传递给C/C++的对像要怎么做处理呢 ？
将对象引用传递给C/C++时 ， C/C++层就会持有Java对象 ， 如果不进行妥善处理 ， 对象多了就会出现内存泄漏问题 ， 所有在C/C++层使用Java对象时 ， 需要释放这个引用 。
下面就来看看数组引用的处理：
// 对数组进行排序
private native void useArraySort(int[] array) ;
public static void main(String[] args) {
// Java数组在C中排序
int[] array = {1,60,20,10,4,90,23} ;
jni.useArraySort(array);
// 输出
for (int i = 0; i < array.length; i++) {
System.out.println("array == "+array[i]);
}
}
将array对象传递给C ， C中的变量将持有array这个引用
// sort
int compare(int* a, int* b) {
return (*a) - (*b);
}
/*对数组进行排序*/
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_useArraySort
(JNIEnv *env, jobject jobj , jintArray jarray) {
jint* arrayElemts = (*env)->GetIntArrayElements(env, jarray, NULL);
jsize arraySize = (*env)->GetArrayLength(env, jarray);
qsort(arrayElemts,arraySize,sizeof(jint),compare);
// 释放引用 ， 因为数组和对象在java中都是引用 ， 都会在堆内存中开辟一块空间 ， 但我们使用完对象之后
// 需要将引用释放掉 ， 不然会很耗内存 ， 在一定程度上可能会造成内存溢出 。
//JNI_ABORT, Java数组不进行更新，但是释放C/C++数组
//JNI_COMMIT，Java数组进行更新，不释放C/C++数组（函数执行完，数组还是会释放）
(*env)->ReleaseIntArrayElements(env, jarray, arrayElemts, JNI_COMMIT);
}
内存示意图：
Java对象引用和C
只要是Java对象 ， 在C中都需要释放，如String类型引用：
// String类型引用释放
void (JNICALL *ReleaseStringUTFChars)
(JNIEnv *env, jstring str, const char* chars);
在C中创建的对象引用也需要进行引用释放
/*返回int类型的数组*/
JNIEXPORT jintArray JNICALL Java_com_zeno_jni_HelloJNI_getIntArray
(JNIEnv *env, jobject jobj,jint len) {
// 创建一个jint类型的数组
jintArray jArray = (*env)->NewIntArray(env, len);
// 得到数组首个元素指针
jint* arrayElements = (*env)->GetIntArrayElements(env, jArray, NULL);
// 指针运算
int i = 0;
for (; i < len; i++)
{
arrayElements[i] = i;
}
// 同步
(*env)->ReleaseIntArrayElements(env, jArray, arrayElements, JNI_COMMIT);
return jArray;
}
java code
// 在C中生存数组 ， 返回到Java中
private native int[] getIntArray(int len) ;
int[] intArray = jni.getIntArray(20);
for (int i = 0; i < intArray.length; i++) {
System.out.println("int array === "+intArray[i]);
}
为什么在C中创建的对象也需要释放 ？
在上述代码中 ， 创建一个数组对象 ， 并将引用传递给了Java层 ， 将引用交给了Java之后 ， C就需要释放这个引用 ， 不然会一直持有 ， GC也不会回收这个对象 。
引用的分级
在Java中引用也有强弱之分 ， 使用new创建的对象就是强引用，也可以使用WeakReference将对象包装成一个弱引用对象 。在C中也不列外 ， C中也有一套全局引用，局部引用，弱全局引用等等 。
一 ， 局部引用
// 局部引用
// 作用：C使用到或自行创建Java对象，需要告知虚拟机在合适的时候回收对象
//局部引用，通过DeleteLocalRef手动释放对象
//1.访问一个很大的java对象，使用完之后，还要进行复杂的耗时操作
//2.创建了大量的局部引用，占用了太多的内存，而且这些局部引用跟后面的操作没有关联性
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_localRef
(JNIEnv *env, jobject jobj) {
// 找到类
jclass dateClass = (*env)->FindClass(env, "java/util/Date");
// 得到构造方法ID
jmethodID dateConstructorId = (*env)->GetMethodID(env, dateClass, "<init>", "()V");
// 创建Date对象
jobject dateObject = (*env)->NewObject(env, dateClass, dateConstructorId);
// 创建一个局部引用
jobject dateLocalRef = (*env)->NewLocalRef(env, dateObject);
// 省略N行代码
// 不再使用对象 ， 则通知GC回收对象
(*env)->DeleteLocalRef(env, dateLocalRef);
// 因为dateObject也是局部对象，可以直接回收dateObject对象
//(*env)->DeleteLocalRef(env, dateObject);
}
全局引用
// 全局引用
// 定义全局引用
//共享(可以跨多个线程)，手动控制内存使用
jstring globalStr;
/*创建全局引用*/
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_createGlobalRef
(JNIEnv *env, jobject jobj) {
jstring jStr = (*env)->NewStringUTF(env, "I want your love !");
// 创建一个全局引用
globalStr = (*env)->NewGlobalRef(env, jStr);
}
/*使用全局引用*/
JNIEXPORT jstring JNICALL Java_com_zeno_jni_HelloJNI_useGlobalRef
(JNIEnv *env, jobject jobj) {
return globalStr;
}
/*释放全局引用*/
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_deleteGlobalRef
(JNIEnv *env, jobject jobj) {
// 释放全局引用
(*env)->DeleteGlobalRef(env, globalStr);
}
//弱全局引用
//节省内存，在内存不足时可以是释放所引用的对象
//可以引用一个不常用的对象，如果为NULL，临时创建
//创建：NewWeakGlobalRef,销毁：DeleteGlobalWeakRef
引用缓存
/*变量缓存*/
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_variableCach
(JNIEnv *env, jobject jobj) {
// 找到String类
jclass stringClass = (*env)->FindClass(env, "java/lang/String");
// 得到构造方法ID
jmethodID stringConstructorID = (*env)->GetMethodID(env, stringClass, "<init>", "()V");
// 创建String类
//// 缓存局部变量 ， 只创建一次 ， 关键字static
static jobject stringObject = NULL;
if (stringObject == NULL)
{
stringObject = (*env)->NewObject(env, stringClass, stringConstructorID);
printf("------------- create String object --------------\n");
}
/*jobject stringObject = (*env)->NewObject(env, stringClass, stringConstructorID);
printf("------------- create String object --------------\n");*/
}
引用的分级 ， 上述代码都有比较详细的注释 ，这里就不多加解释了 ， 说一下全局引用的简单使用场景。
在开发中 ， 我们常常需要初始化一些变量 ， 进行全局使用 ， 这里我们的全局引用就发挥了作用了 。
// 初始化全局变量
//初始化全局变量，动态库加载完成之后，立刻缓存起来
jstring initGlobalStr;
JNIEXPORT void JNICALL Java_com_zeno_jni_HelloJNI_initVariable
(JNIEnv *env, jclass jcls) {
jstring initStr = (*env)->NewStringUTF(env, "create global init variable ");
initGlobalStr = (*env)->NewGlobalRef(env, initStr);
}
/*访问初始化全局变量*/
JNIEXPORT jstring JNICALL Java_com_zeno_jni_HelloJNI_accessInitGlobalVariable
(JNIEnv *env, jobject jobj) {
return initGlobalStr;
}
__java code__
static{
// 加载动态库
System.loadLibrary("Hello_JNI") ;
// 初始化全局变量
initVariable();
}
C中引用的分级和在Java中的类型 ， 都需要在合适的环境使用 。
结语
这是JNI系列的最后一篇 ， 在这个系列中 ， 我们大致了解了JNI的开发流程， 以及一些常用的API和技法 ， 在下篇中 ， 我们正式进入NDK开发 ， 将我们在JNI中学到的应用起来 。NDK基础过后 ， 将会进入到C++语言的学习 ， 我们要学会使用第三方C/C++库 。
本系列由动脑学院提供技术支持 ， 动脑学院 -- 做一家受人尊重的企业，做一个令人尊敬的老师 ！
