Android NDK基础12：JNI数组处理_JNI引用变量

JNI数组处理

传入数组

public class JniTest {

    public native void giveArray(int[] arr);

    public static void main(String[] args) {
        JniTest t = new JniTest();
        int arr = {9, 100, 10, 37, 5, 10};
        //排序
        t.giveArray(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    //加载动态库
    static {    
        System.loadLibrary("JniTest");
    }

}

#include <stdio.h>
#include <stdlib.h>

int compare(int *a, int *b) {
    return (*a) - (*b);
}

//传入数组
JNIEXPORT void JNICALL Java_cn_appblog_jni_JniTest_giveArray
  (JNIEnv *env, jobject jobj, jintArray arr) {
    //jintArray -> jint指针 -> c int 数组
    jint *elems = (*env)->GetIntArrayElements(env, arr, NULL); //实际测试表明是复制数组
    //printf("%#x,%#x\n", &elems, &arr);

    //数组的长度
    int len = (*env)->GetArrayLength(env, arr);
    //排序
    qsort(elems, len, sizeof(jint), compare);    

    //同步
    //第三个参数mode
    //0：Java数组进行更新，并且释放C/C++数组
    //JNI_ABORT：Java数组不进行更新，但是释放C/C++数组
    //JNI_COMMIT：Java数组进行更新，不释放C/C++数组（函数执行完，数组还是会释放）
    (*env)->ReleaseIntArrayElements(env, arr, elems, JNI_COMMIT);
}

返回数组

public class JniTest {

    public native void getArray(int len);

    public static void main(String[] args) {
        JniTest t = new JniTest();
        int[] arr = t.getArray(10);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    //加载动态库
    static {    
        System.loadLibrary("JniTest");
    }

}

//返回数组
JNIEXPORT jintArray JNICALL Java_cn_appblog_jni_JniTest_getArray(JNIEnv *env, jobject jobj, jint len) {
    //创建一个指定大小的数组
    jintArray jint_arr = (*env)->NewIntArray(env, len);
    jint *elems = (*env)->GetIntArrayElements(env, jint_arr, NULL);    
    int i = 0;
    for (; i < len; i++) {
        elems[i] = i;
    }

    //同步
    (*env)->ReleaseIntArrayElements(env, jint_arr, elems, 0);    

    return jint_arr;
}

JNI引用变量

引用类型：局部引用和全局引用

作用：在JNI中告知虚拟机何时回收一个JNI变量

局部引用

//局部引用，通过DeleteLocalRef手动释放对象
//1.访问一个很大的java对象，使用完之后，还要进行复杂的耗时操作
//2.创建了大量的局部引用，占用了太多的内存，而且这些局部引用跟后面的操作没有关联性

//模拟：循环创建数组
JNIEXPORT void JNICALL Java_cn_appblog_jni_JniTest_localRef(JNIEnv *env, jobject jobj) {
    int i = 0;
    for (; i < 5; i++) {
        //创建Date对象
        jclass cls = (*env)->FindClass(env, "java/util/Date");
        jmethodID constructor_mid = (*env)->GetMethodID(env, cls, "<init>", "()V");
        jobject obj = (*env)->NewObject(env, cls, constructor_mid);
        //此处省略一百行代码...

        //不再使用jobject对象
        //通知垃圾回收器回收这些对象
        (*env)->DeleteLocalRef(env, obj);
        //此处省略一百行代码...
    }
}

全局引用

//全局引用
//共享(可以跨多个线程)，手动控制内存使用
jstring global_str;

//创建
JNIEXPORT void JNICALL Java_cn_appblog_jni_JniTest_createGlobalRef(JNIEnv *env, jobject jobj) {
    jstring obj = (*env)->NewStringUTF(env, "Jni development is powerful!");
    global_str = (*env)->NewGlobalRef(env, obj);
}

//获得
JNIEXPORT jstring JNICALL Java_cn_appblog_jni_JniTest_getGlobalRef(JNIEnv *env, jobject jobj) {
    return global_str;
}

//释放
JNIEXPORT void JNICALL Java_cn_appblog_jni_JniTest_deleteGlobalRef(JNIEnv *env, jobject jobj) {
    (*env)->DeleteGlobalRef(env, global_str);
}

弱全局引用

//节省内存，在内存不足时可以是释放所引用的对象
//可以引用一个不常用的对象，如果为NULL，临时创建
//创建：NewWeakGlobalRef，销毁：DeleteGlobalWeakRef

Java调用

public class JniTest {

    public native void localRef();

    public native void createGlobalRef();
    public native String getGlobalRef();
    public native void deleteGlobalRef();

    public static void main(String[] args) {
        JniTest t = new JniTest();
        t.createGlobalRef();
        System.out.println(t.getGlobalRef());
        //用完之后释放
        t.deleteGlobalRef();
        System.out.println("已释放");
        //System.out.println(t.getGlobalRef());
    }

    //加载动态库
    static {    
        System.loadLibrary("JniTest");
    }

}