JNI/NDK开发指南（五）——访问数组（基本类型数组与对象数组）

JNI中的数组分为基本类型数组和对象数组，它们的处理方式是不同的，基本类型数组中的全部元素都是JNI的基本数据类型，能够直接访问。而对象数组中的全部元素是一个类的实例或其它数组的引用，和字符串操做同样，不能直接访问Java传递给JNI层的数组，必须选择合适的JNI函数来访问和设置Java层的数组对象。阅读此文假设你已经了解了JNI与Java数据类型的映射关系，若是还不了解的童鞋，请移步《JNI/NDK开发指南（三）——JNI数据类型及与Java数据类型的映射关系》阅读。下面以int类型为例说明基本数据类型数组的访问方式，对象数组类型用一个建立二维数组的例子来演示如何访问：

1、访问基本类型数组

package com.study.jnilearn;
 
// 访问基本类型数组
public class IntArray {
 
    // 在本地代码中求数组中全部元素的和
    private native int sumArray(int[] arr);
    
    public static void main(String[] args) {
        IntArray p = new IntArray();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
        int sum = p.sumArray(arr);
        System.out.println("sum = " + sum);
    }
 
    static {
        System.loadLibrary("IntArray");
    }
}
本地代码：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_study_jnilearn_IntArray */
 
#ifndef _Included_com_study_jnilearn_IntArray
#define _Included_com_study_jnilearn_IntArray
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_study_jnilearn_IntArray
 * Method:    sumArray
 * Signature: ([I)I
 */
JNIEXPORT jint JNICALL Java_com_study_jnilearn_IntArray_sumArray
  (JNIEnv *, jobject, jintArray);
 
#ifdef __cplusplus
}
#endif
#endif
 
// IntArray.c
#include "com_study_jnilearn_IntArray.h"
#include <string.h>
#include <stdlib.h>
 
/*
 * Class:     com_study_jnilearn_IntArray
 * Method:    sumArray
 * Signature: ([I)I
 */
JNIEXPORT jint JNICALL Java_com_study_jnilearn_IntArray_sumArray
(JNIEnv *env, jobject obj, jintArray j_array)
{
    jint i, sum = 0;
    jint *c_array;
    jint arr_len;
    //1. 获取数组长度
    arr_len = (*env)->GetArrayLength(env,j_array);
    //2. 根据数组长度和数组元素的数据类型申请存放java数组元素的缓冲区
    c_array = (jint*)malloc(sizeof(jint) * arr_len);
    //3. 初始化缓冲区
    memset(c_array,0,sizeof(jint)*arr_len);
    printf("arr_len = %d ", arr_len);
    //4. 拷贝Java数组中的全部元素到缓冲区中
    (*env)->GetIntArrayRegion(env,j_array,0,arr_len,c_array);
    for (i = 0; i < arr_len; i++) {
        sum += c_array[i];  //5. 累加数组元素的和
    }
    free(c_array);  //6. 释放存储数组元素的缓冲区
    return sum;
}
上例中，在Java中定义了一个sumArray的native方法，参数类型是int[]，对应JNI中jintArray类型。在本地代码中，首先经过JNI的GetArrayLength函数获取数组的长度，已知数组是jintArray类型，能够得出数组的元素类型是jint，而后根据数组的长度和数组元素类型，申请相应大小的缓冲区。若是缓冲区不大的话，固然也能够直接在栈上申请内存，那样效率更高，可是没那么灵活，由于Java数组的大小变了，本地代码也跟着修改。接着调用GetIntArrayRegion函数将Java数组中的全部元素拷贝到C缓冲区中，并累加数组中全部元素的和，最后释放存储java数组元素的C缓冲区，并返回计算结果。GetIntArrayRegion函数第1个参数是JNIEnv函数指针，第2个参数是Java数组对象，第3个参数是拷贝数组的开始索引，第4个参数是拷贝数组的长度，第5个参数是拷贝目的地。下图是计算结果：

在前面的例子当中，咱们经过调用GetIntArrayRegion函数，将int数组中的全部元素拷贝到C临时缓冲区中，而后在本地代码中访问缓冲区中的元素来实现求和的计算，JNI还提供了一个和GetIntArrayRegion相对应的函SetIntArrayRegion，本地代码能够经过这个函数来修改全部基本数据类型数组的元素。另外JNI还提供一系列直接获取数组元素指针的函数Get/Release<Type>ArrayElements，好比：GetIntArrayElements、ReleaseArrayElements、GetFloatArrayElements、ReleaseFloatArrayElements等。下面咱们用这种方式从新实现计算数组元素的和：

JNIEXPORT jint JNICALL Java_com_study_jnilearn_IntArray_sumArray2
(JNIEnv *env, jobject obj, jintArray j_array)
{
    jint i, sum = 0;
    jint *c_array;
    jint arr_len;
    // 可能数组中的元素在内存中是不连续的，JVM可能会复制全部原始数据到缓冲区，而后返回这个缓冲区的指针
    c_array = (*env)->GetIntArrayElements(env,j_array,NULL);
    if (c_array == NULL) {
        return 0;   // JVM复制原始数据到缓冲区失败
    }
    arr_len = (*env)->GetArrayLength(env,j_array);
    printf("arr_len = %d\n", arr_len);
    for (i = 0; i < arr_len; i++) {
        sum += c_array[i];
    }
    (*env)->ReleaseIntArrayElements(env,j_array, c_array, 0); // 释放可能复制的缓冲区
    return sum;
}
GetIntArrayElements第三个参数表示返回的数组指针是原始数组，仍是拷贝原始数据到临时缓冲区的指针，若是是JNI_TRUE：表示临时缓冲区数组指针，JNI_FALSE：表示临时原始数组指针。开发当中，咱们并不关心它从哪里返回的数组指针，这个参数填NULL便可，但在获取到的指针必须作校验，由于当原始数据在内存当中不是连续存放的状况下，JVM会复制全部原始数据到一个临时缓冲区，并返回这个临时缓冲区的指针。有可能在申请开辟临时缓冲区内存空间时，会内存不足致使申请失败，这时会返回NULL。
    写过Java的程序员都知道，在Java中建立的对象全都由GC（垃圾回收器）自动回收，不须要像C/C++同样须要程序员本身管理内存。GC会实时扫描全部建立的对象是否还有引用，若是没有引用则会当即清理掉。当咱们建立一个像int数组对象的时候，当咱们在本地代码想去访问时，发现这个对象正被GC线程占用了，这时本地代码会一直处于阻塞状态，直到等待GC释放这个对象的锁以后才能继续访问。为了不这种现象的发生，JNI提供了Get/ReleasePrimitiveArrayCritical这对函数，本地代码在访问数组对象时会暂停GC线程。不过使用这对函数也有个限制，在Get/ReleasePrimitiveArrayCritical这两个函数期间不能调用任何会让线程阻塞或等待JVM中其它线程的本地函数或JNI函数，和处理字符串的Get/ReleaseStringCritical函数限制同样。这对函数和GetIntArrayElements函数同样，返回的是数组元素的指针。下面用这种方式从新实现上例中的功能：

JNIEXPORT jint JNICALL Java_com_study_jnilearn_IntArray_sumArray
(JNIEnv *env, jobject obj, jintArray j_array)
{
    jint i, sum = 0;
    jint *c_array;
    jint arr_len;
    jboolean isCopy;
    c_array = (*env)->GetPrimitiveArrayCritical(env,j_array,&isCopy);
    printf("isCopy: %d \n", isCopy);
    if (c_array == NULL) {
        return 0;
    }
    arr_len = (*env)->GetArrayLength(env,j_array);
    printf("arr_len = %d\n", arr_len);
    for (i = 0; i < arr_len; i++) {
        sum += c_array[i];
    }
    (*env)->ReleasePrimitiveArrayCritical(env, j_array, c_array, 0);
    return sum;
}
小结：

一、对于小量的、固定大小的数组，应该选择Get/SetArrayRegion函数来操做数组元素是效率最高的。由于这对函数要求提早分配一个C临时缓冲区来存储数组元素，你能够直接在Stack（栈）上或用malloc在堆上来动态申请，固然在栈上申请是最快的。有童鞋可能会认为，访问数组元素还须要将原始数据所有拷贝一份到临时缓冲区才能访问而以为效率低？我想告诉你的是，像这种复制少许数组元素的代价是很小的，几乎能够忽略。这对函数的另一个优势就是，容许你传入一个开始索引和长度来实现对子数组元素的访问和操做（SetArrayRegion函数能够修改数组），不过传入的索引和长度不要越界，函数会进行检查，若是越界了会抛出ArrayIndexOutOfBoundsException异常。

二、若是不想预先分配C缓冲区，而且原始数组长度也不肯定，而本地代码又不想在获取数组元素指针时被阻塞的话，使用Get/ReleasePrimitiveArrayCritical函数对，就像Get/ReleaseStringCritical函数对同样，使用这对函数要很是当心，以避免死锁。

三、Get/Release<type>ArrayElements系列函数永远是安全的，JVM会选择性的返回一个指针，这个指针可能指向原始数据，也可能指向原始数据的复制。

2、访问对象数组

       JNI提供了两个函数来访问对象数组，GetObjectArrayElement返回数组中指定位置的元素，SetObjectArrayElement修改数组中指定位置的元素。与基本类型不一样的是，咱们不能一次获得数据中的全部对象元素或者一次复制多个对象元素到缓冲区。由于字符串和数组都是引用类型，只能经过Get/SetObjectArrayElement这样的JNI函数来访问字符串数组或者数组中的数组元素。下面的例子经过调用一个本地方法来建立一个二维的int数组，而后打印这个二维数组的内容：

package com.study.jnilearn;
 
public class ObjectArray {
 
    private native int[][] initInt2DArray(int size);
    
    public static void main(String[] args) {
        ObjectArray obj = new ObjectArray();
        int[][] arr = obj.initInt2DArray(3);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.format("arr[%d][%d] = %d\n", i, j, arr[i][j]);
            }
        }
    }
 
    static {
        System.loadLibrary("ObjectArray");
    }
}
本地代码：
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_study_jnilearn_ObjectArray */
 
#ifndef _Included_com_study_jnilearn_ObjectArray
#define _Included_com_study_jnilearn_ObjectArray
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_study_jnilearn_ObjectArray
 * Method:    initInt2DArray
 * Signature: (I)[[I
 */
JNIEXPORT jobjectArray JNICALL Java_com_study_jnilearn_ObjectArray_initInt2DArray
  (JNIEnv *, jobject, jint);
 
#ifdef __cplusplus
}
#endif
#endif
 
 
// ObjectArray.c
 
#include "com_study_jnilearn_ObjectArray.h"
/*
 * Class:     com_study_jnilearn_ObjectArray
 * Method:    initInt2DArray
 * Signature: (I)[[I
 */
JNIEXPORT jobjectArray JNICALL Java_com_study_jnilearn_ObjectArray_initInt2DArray
  (JNIEnv *env, jobject obj, jint size)
{
    jobjectArray result;
    jclass clsIntArray;
    jint i,j;
    // 1.得到一个int型二维数组类的引用
    clsIntArray = (*env)->FindClass(env,"[I");
    if (clsIntArray == NULL)
    {
        return NULL;
    }
    // 2.建立一个数组对象（里面每一个元素用clsIntArray表示）
    result = (*env)->NewObjectArray(env,size,clsIntArray,NULL);
    if (result == NULL)
    {
        return NULL;
    }
    
    // 3.为数组元素赋值
    for (i = 0; i < size; ++i)
    {
        jint buff[256];
        jintArray intArr = (*env)->NewIntArray(env,size);
        if (intArr == NULL)
        {
            return NULL;
        }
        for (j = 0; j < size; j++)
        {
            buff[j] = i + j;
        }
        (*env)->SetIntArrayRegion(env,intArr, 0,size,buff);
        (*env)->SetObjectArrayElement(env,result, i, intArr);
        (*env)->DeleteLocalRef(env,intArr);
    }
    
    return result;
}
结果：

     本地函数initInt2DArray首先调用JNI函数FindClass得到一个int型的二维数组类的引用，传递给FindClass的参数"[I"是JNI class descript（JNI类型描述符，后面为详细介绍），它对应着JVM中的int[]类型。若是int[]类加载失败的话，FindClass会返回NULL，而后抛出一个java.lang.NoClassDefFoundError: [I异常。

     接下来，NewObjectArray建立一个新的数组，这个数组里面的元素类型用intArrCls(int[])类型来表示。函数NewObjectArray只能分配第一维，JVM没有与多维数组相对应的数据结构，JNI也没有提供相似的函数来建立二维数组。因为JNI中的二维数组直接操做的是JVM中的数据结构，相比JAVA和C/C++建立二维数组要复杂不少。给二维数组设置数据的方式也很是直接，首先用NewIntArray建立一个JNI的int数组，并为每一个数组元素分配空间，而后用SetIntArrayRegion把buff[]缓冲中的内容复制到新分配的一维数组中去，最后在外层循环中依次将int[]数组赋值到jobjectArray数组中，一维数组中套一维数组，就造成了一个所谓的二维数组。

     另外，为了不在循环内建立大量的JNI局部引用，形成JNI引用表溢出，因此在外层循环中每次都要调用DeleteLocalRef将新建立的jintArray引用从引用表中移除。在JNI中，只有jobject以及子类属于引用变量，会占用引用表的空间，jint，jfloat，jboolean等都是基本类型变量，不会占用引用表空间，即不须要释放。引用表最大空间为512个，若是超出这个范围，JVM就会挂掉。

示例代码下载地址：https://code.csdn.net/xyang81/jnilearn