Android JNI 介绍

Android开发中避免不了会用到C/C++代码来提高应用程序的性能和安全性,由于android开发使用Java代码,这就需要Java与C/C++的相互调用。JNI即是链接Java层与C/C++的桥梁。通过JNI我们可以在Java代码中调用C/C++代码,也可在C/C++代码中调用Java代码。下面简述JNI开发中使用到的相关知识。

一. Java中调用native方法

要在Java中调用本地方法,首先要在Java类中使用”native” 关键字声明本地方法,该方法与C/C++编写的JNI本地方法对应。”native”关键字是告知Java编译器,在Java代码中带有该关键字的方法只是声明,具体有C/C++编写实现。native方法中参数可以使用任何类型。包括基本类型,数组类型,复杂对象等。
看下面的例子:

//包com.example
class HelloJNI {
    //加载JNI库
    static {
        System.loadLibrary("hellojni");
    }
    //声明本地方法
    private native void printHello();
    
    public static void main(String args[]) {
        HelloJNI jni = new HelloJNI();
        //本地方法调用
        jni.printHello();
    }
}

Java中调用本地方法,还需要加载C/C++实现的运行库。上面例子中,System.loadLibrary(“hellojni”)即是加载本地库。其中参数是字符串,也就是加载的本地库的文件名称的一部分。在linux平台中,本地库的命名规则为lib + 名称 + .so 。即动态库的名称必须以lib开头,中间的名称即是loadLibrary方法传入的参数。如动态库libhellojni.so,加载要写为System.loadLibrary(“hellojni”)。为什么不把名字写全比如”libhellojni.so“。因为java是跨平台的,不同的平台后缀不同,Linux下为.so。window下为.dll,其他平台的命名规则也不相同。这样可以保证java代码在不同的平台中直接运行而不需要再修改代码。
Java中调用native方法也和普通Java方法没有区别。

二. JNI命名规则

在编写Java中定义的native方法对应的C/C++代码时需要遵循一定的命名规范
比如上面的native方法printHello,在C/C++层的函数原型为:

JNIEXPORT void JNICALL Java_com_example_HelloJNI_printHello(JNIEnv*, jobject);

只要按照以上的函数原型规则编写,虚拟就可以把本地库函数和Java本地方法链接在一起。
JNIEXPORT,JNICALL都是JNI的关键字,表示此函数要被JNI调用,函数原型中必须有这2个关键字,JNI才能正常调用函数。这2个关键字其实都是宏定义。
从上可以看到函数名遵循命名规范:Java_类名_本地方法名。通过该规范可以知道该JNI函数与Java的哪个类的哪个本地方法对应。
再来看看函数原型中的参数,第一个参数JNIEnv*是JNI接口的指针,用来调用JNI表中的各种JNI函数(JNI函数提供的基本函数集)。每个线程一个JNIEnv指针。第二个参数是jobject,是JNI提供的Java本地类型,用来在C/C++代码中访问Java对象,此参数中保存着调用本地方法的对象的一个引用。根据上的例子:jni.printHello()。 jni调用了本地方法printHello(),所以jobject中保存着对jni对象的引用。如果本地方法是静态方法,第二个参数类型为jclass。
这个2个参数是默认参数,支持JNI的函数必须包含这2个参数。从第二个参数以后的参数才是本地方法带有的参数。这个例子中,本地方法没有参数,所以只有2个默认参数,没有更多参数。

三. Java类型的在JNI中的表示

Java程序与C/C++函数之间经常需要进行数据交换,2种语言都有自己的数据类型,不能相互使用。为了能够进行数据交换,JNI提供了一套与Java数据类型相对应的Java本地类型,使得本地语言可以使用Java数据类型。在JNI编程时,从Java代码中接收或者传递数据时,只要使用Java本地类型即可。
Java类型和Java本地类型的映射关系:

Java类型 Java本地类型 内存(字节)
byte jbyte 1
short jshort 2
int jint 4
long jlong 8
float jfloat 4
double jdouble 8
char jchar 2
boolean jboolean 1
void void

以上是对应的基本Java类型,在Java还有各种Java类,对象等引用数据类型。在Java本地类型中也提供了对应的引用数据类型,如下。

Java引用类型 Java本地类型
jclass
对象 jobject
String jstring

Java本地类型jstring对应的Java中的String类型在内存中占用16位,而C语言中的字符串仅占8位,所以在C语言中无法直接使用jstring因此需要将jstring类型的字符串转成C字符串。

转换方法:

将Java字符串对象转成UTF-8字符串(C字符串), 并返回指针

const jbyte* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)

*env:JNI接口指针

string:Java字符串对象

*isCopy:用于指示是否复制字符串,为NULL,则表示不复制字符串,返回的指针指向Java字符串的内部存储,在调用ReleaseStringUTFChars()函数时,JNI会释放Java字符串内部存储区域中的C字符串指针。如果参数为非零值,则表示复制字符串,返回的指针指向新分配的内存空间,需要在使用完后手动释放,此时在调用ReleaseStringUTFChars()函数时,JNI会释放通过GetStringUTFChars()函数复制的新的C字符串指针。

在处理完C字符串后,需要使用ReleaseStringUTFChars()函数释放C字符串,以避免内存泄漏。
void ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars);

env:JNIEnv* 类型的指针,代表JNI环境。

str:jstring类型的参数,代表要释放的Java字符串。

chars:const char* 类型的参数,代表要释放的C字符串指针。

使用GetStringUTFChars()函数获取的C字符串是以UTF-8编码格式表示的。如果需要使用其他编码格式,可以使用GetStringChars()函数获取Unicode字符数组,然后根据需要进行转换。

另外Java中还有数组类型比如byte[]对应jbyteArrary, char[]对应jcharArray。其实只是jobject通过typedef定义出来的别名。

Java数组 Java本地类型
byte[] jbyteArrary
short[] jshortArrary
int[] jintArrary
long[] jlongArrary
float[] jfloatArrary
double[] jdoubleArrary
char[] jcharArrary
boolean[] jbooleanArrary

四. 参数签名

在JNI中参数签名在非常重要,我们经常需要获取Java方法和字段ID,调用Java方法,访问Java字段等操作。如何在JNI中描述Java方法的参数和返回类型,就需要用到参数签名。通过参数签名JNI可以描述Java方法的参数和返回类型,并将他们转换为C/C++中对应的数据类型,以便在C/C++中处理
以下参数签名和Java参数的对应关系

参数签名 Java参数
Z boolean
C char
B byte
I int
S short
J long
F float
D double
V void

复杂类型的参数签名:”L”加全限定类名再加”;”。如:String类的参数签名:”L/java/lang/String;”对应的JNI类型是jstring,其余java复杂类型对应的JNI类型都是jobject类型。
参数签名中数组的的表示方法是在基本类型符号前加符号”[“,比如boolean[]的参数签名为[Z,以此类推。

五. JNI中调用Java

JNI中不可避免要调用到Java代码。JNI提供了一系列方法供开发者使用。

生成Java对象

生成一个java对象可以使用函数NewObject()原型如下:
jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, …);

参数clazz指java类对象(不是类的实例对象),可以通过函数FindClass()得到。

参数methodID是java类的构造方法ID。

返回类型jobject用来表示生成的Java对象。

FindClass()函数原型:

jclass FindClass(const char* name);

参数name是java类的名称,如“L/java/lang/String”

… : 可变参数列表,用于传递构造函数的参数。

例子,生成Date对象:

jclass dateClass = (*env)->FindClass(env, "java/util/Date");
//获得构造函数ID
jmethodID dateConstructor = (*env)->GetMethodID(env, dateClass, "<init>", "()V");
//获得Date对象。java复杂类型的对应的JNI类型都是jobject,所以返回的dateObject是jobject类型的对象
jobject dateObject = (*env)->NewObject(env, dateClass, dateConstructor);

在GetMethodID方法中,第3个参数传的值为””, 它表示构造函数名称。”()V”是构造函数的参数签名,构造函数没有参数则只写”()”,V表示返回类型为void。

调用java类的方法

得到了java对象后,调用java类的方法就简单了。JNIEnv提供了很多调用java类中的方法函数,这些函数根据java方法的返回值来定义。

原型:

void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jboolean CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jbyte CallByteMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, …);

参数含义:

env:指向JNI环境的指针。

obj:Java对象的引用。

methodID:Java方法的方法ID。

…:可变参数列表,用于传递Java方法的参数。

JNI调用Java方法先要获取方法的jmethodID,传入到对应的方法中,可变列表传入方法的参数签名,需要按照Java方法的参数类型和顺序来传递参数。

获取方法ID函数原型:

jmethodID GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);

参数含义:

env:指向JNI环境的指针。

clazz:Java类的引用。

name:Java方法的名称。

sig:Java方法的签名。用于表示Java方法的参数类型和返回值类型。签名的格式为”(参数类型…)返回值类型”,如果public int add(int a, int b)方法,其签名为”(II)I”

在调用Java方法时,需要先获取Java方法的方法ID。当调用的是java静态方法时,也有对应的静态方法原型:

void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, …);

参数含义:

env:指向JNI环境的指针。

clazz:Java类的引用。

methodID:Java静态方法的方法ID。

…:可变参数列表,用于传递Java静态方法的参数。

和调用Java方法一样,调用静态方法首先要获取方法的jmethodID。

原型为:

jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);

存取java类的域变量

JNI也可以对Java类的变量进行存取操作,JNIEnv分别定义了一组函数来读写域变量。

读取变量的原型:

jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID);

jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID);

jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID);

jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID);

jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID);

jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID);

jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID);

jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID);

在调用方法获取变量值之前,需要获取Java类的实例变量的jfieldID。

获取原型为:

jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);

参数含义:

env:指向JNI环境的指针。

clazz:Java类的引用。

name:Java变量的名称。

sig:Java变量的签名。

读取静态变量的函数原型:

jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID);

jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID);

获取Java类的静态变量的变量ID,函数原型为:

jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);

参数含义:

env:指向JNI环境的指针。

clazz:Java类的引用。

name:Java变量的名称。

sig:Java变量的签名。

设置变量的函数原型:

void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value);

void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value);

void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value);

void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value);

void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value);

void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value);

void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value);

void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value);

设置静态变量的函数原型:

void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);

void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);

void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);

void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);

void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);

void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);

void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);

void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);

六. JNI的异常处理

在JNI中检查Java层中发生的例外

android的C++层不支持try-catch机制。如果JNI中调用java层的方法发生了例外,则JNI调用会正常返回,但是继续调用其他JNI函数可能会导致崩溃。所以JNI中提供了一组函数来检查java方法是否抛出了例外。

jthrowable ExceptionOccurred(); //检查是否有例外发生

void ExceptionDescribe(); //打印输出Exception的信息

void ExceptionClear(); //清除例外

jclass clazz = env->FindClass("android/content/Intent");
if (env->ExceptionOccurred() != NULL) {
    env->ExceptionDescribe();
    env->ExceptionClear();
}
在JNI中抛出例外

如果要在JNI中抛出例外可以使用以下函数:
jint ThrowNew(jclass clazz, const char* message) //用来新生成一个例外并向外抛出,参数clazz 是指java中的Exception类以及其派生类的类对象
jint jniThrowException(JNIEnv *env, const char *className, const char *msg);
jniThrowException()函数是在JNI代码中抛出Java异常的一种方式。它可以抛出预定义的Java异常,如IllegalArgumentException、IllegalStateException等。ThrowNew()函数可以在本地代码中灵活地抛出任何Java异常,而不仅仅是预定义的异常。预定义异常是指,这些异常类已经在Java标准库中定义好了的,而不是开发者自定义的异常类。

在JNIHelp中也定了几个函数来方便抛出一些常见的例外,如空指针

//抛出例外“java/lang/NullPointerException”
//参数message: 异常消息。可以为NULL。
void jniThrowNullPointerException(JNIEnv *env, const char *message);
//抛出例外“java/lang/RuntimeException”
//参数message: 异常消息。可以为NULL。
void jniThrowRuntimeException(JNIEnv *env, const char *message);
//抛出例外“java/lang/IOException”
//参数errnum:错误码。必须是一个有效的系统错误码。
void jniThrowIOException(JNIEnv *env, jint errnum);

抛出异常后,函数会立即返回,不再执行后续代码。因此,调用该函数后的代码应该不依赖于函数的返回值,而是依赖于异常处理机制来处理异常。

七. JNI中的引用

JNI中创建的java对象和java层创建的对象并没有区别,它们的生命周期是一致的。
下面介绍JNI中对象的引用类型。

局部引用(LocalReference)

局部引用在JNI本地函数中生成,他们的生命周期应该在函数退出时结束。当本地方法返回时,所有局部引用都会被自动释放。局部引用是JNI默认的,也可以使用NewLocalRef()函数创建。虚拟机如何做到函数执行期不回收,退出函数就回收?每个java线程中都有一张本地引用(LocalReference)表,虚拟机不回收这张表里的对象。本地函数执行期间,JNIEnv隐式地把java对象都加入到本地引用表中了。(注意:如果本地函数生成的java对象希望留给下次调用使用,不能把它保存在一个本地全局静态变量中,这样并不能阻止它被回收掉)。

全局引用(GlobalReference)

全局引用可以在本地方法中创建,但是在本地方法返回后,不会被回收。JNIEnv提供了一个函数NewGlobalRef()函数:jobject NewGlobalRef(JNIEnv* env, jobject obj);这个函数的作用是将java对象从本地引用表中删除掉,然后放入全局引用表中。放入全局引用表中的java对象不会被回收。全局引用对象需要显式删除,原型为:void DeleteGlobalRef(JNIEnv *env, jobject globalRef);

该函数把对象从全局引用表中删除,不立刻回收对象,等下次系统垃圾回收时才会真正释放。

弱全局引用(WeakGlobalReference)

弱全局引用与全局引用类似,但它只是暂时保存对象,下次垃圾回收时将会被回收,原型:

jweak NewWeakGlobalRef(JNIEnv *env, jobject obj); //创建弱全局引用

void DeleteWeakGlobalRef(JNIEnv *env, jweak weakRef); // 删除弱全局引用

八. JNI函数注册

虚拟机在运行包含本地方法的java应用程序时,经历一下步骤。

1.调用System.loadLibrary() 方法,将包含本地方法具体实现的C/C++运行库加载到内存中

2.虚拟机检索加载进来的库函数符号,在其中查找与java本地方法拥有相同签名的JNI本地函数符号,如找到一致的,则将本地方法映射到具体的JNI本地函数。

如果JNI本地函数只有少数几个,Java虚拟机在将本地方法与C运行库中的JNI本地函数映射在一起,不会耗费太长时间。但在Android Framework复杂的系统下,有大量的包含本地方法的Java类。虚拟机加载相应运行库,再逐一检索,将各个本地方法与相应的函数映射起来,显然会增加运行时间,降低效率。为了解决这一问题,JNI提供了名称为RegisterNatives()的JNI函数,该函数允许C/C++开发者将JNI本地函数与java类的本地方法直接映射在一起。当不调用RegisterNatives()函数时,Java虚拟机会自动检索并将JNI本地函数与相应的Java本地方法链接在一起。当开发者直接调用RegisterNatives()函数进行隐射时,Java虚拟机就不必进行映射处理,这会极大提高运行速度,提升运行效率。由于是开发直接将JNI本地函数与Java本地方法链接在一起,在加载运行库时虚拟机不必为了识别JNI本地函数将JNI本地函数的名称与JNI支持的命名规则进行对比,即任何名称的函数都能直接连接到Java本地方法上。

再看看System.loadLibrary()方法的执行过程,在调用System.loadLibrary()时,首先虚拟机加载其参数指定的共享库,并检索共享库内的函数符号,检查JNI_OnLoad()函数是否被实现,若共享库中含有相关函数,则JNI_OnLoad()函数会被自动调用。如果未被实现,虚拟机会自动将本地方法与库内的JNI本地函数符号进行比较匹配。

如果,开发者想手工映射本地方法与JNI本地函数,需要实现JNI_OnLoad()函数,并在JNI_OnLoad()函数内部调用RegisterNaives()函数进行映射匹配。

JNI_OnLoad()函数必须返回有关JNI版本的信息,通过JNI_OnLoad()函数,虚拟机可以在加载本地库时对JNI进行初始化。

JNI_OnLoad()函数:

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved);

vm:指向Java虚拟机的指针。该指针可以用来与Java虚拟机进行交互,如获取当前线程、获取Class对象等。

reserved:指向一个保留参数的指针。该参数保留,目前没有使用。

返回值:是一个整数值,用于指示JNI版本号

在使用加载库的过程中,JNI_OnLoad()函数会向虚拟机确认JNI的版本。如果库中不包含JNI_OnLoad()函数, 虚拟机会认为相关库要求JNI1.1版本支持。

特别注意:在JNI_OnLoad()函数中,不应该调用Java方法,因为此时Java虚拟机还没有完全初始化完成。

RegisterNatives函数原型:

JNIEXPORT jint JNICALL RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);

函数参数:

env:指向JNI环境的指针。

clazz:要注册本地方法的Java类对象。

methods:指向一个JNINativeMethod结构体数组的指针,其中包含要注册的本地方法的信息,包括方法名、方法签名和本地方法的函数指针。

nMethods:要注册的本地方法的数量。

如何实现JNI_OnLoad,以及注册本地方法,例子:

# include " jni . h "
# include < stdio.h >
// JNI 本地函数原型 
// RegisterNatives函数进行映射时,不需要将JNI本地函数原型与JNI命名规则进行比较,但是函数中的2个公共参数必须指定为"JNIEnv * env , jobjectobj"
void printHelloNative ( JNIEnv * env , jobjectobj ); 
void printStringNative ( JNIEnv * env , jobject obj , jstring string ); JNIEXPORT jint JNICALL JNI_OnLoad ( JavaVM * vm , void *reserved ) 
{
    JNIEnv *env = NULL; 
    JNINativeMethod nm [2]; 
    jclass cls; 
    jint result = -1; 
    
    if ( vm->GetEnv (( void **) & env, JNI_VERSION_1_4) != JNI _ OK )
    { 
        printf ("Error"); 
        return JNI_ERR;
    } 
    // 为了把上面声明的JNI本地函数与HelloJNI类的本地方法链接到一起。本行先调用FindClass()函数加载HelloJNI类,并将类引用保存到jclass变量cls中。
    cls = env -> FindClass ("HelloJNI ");
    
    //以下代码用来将Java类的本地方法与JNI本地函数映射在一起。使用JNINativeMethod结构体数组,将待映射的本地方法与JNI本地函数的相关信息保存在数组中。
    nm[O].name = "printHello"; 
    nm[0].signature = "()V"; 
    nm[0].fnPtr = ( void *) printHelloNative ; 
    nm[1].name = "printString"; 
    nm[1].signature = "(Ljava/lang/String;)V "; 
    nm[1].fnPtr = ( void *)printStringNative; 
    //数组传给RegisterNatives 完成映射
    env -> RegisterNatives ( cls , nm , 2); 
    return JNI_VERSION_1_4;
    
}

//实现 JNI 本地函数 
void printHelloNative ( JNIEnv *env , jobject obj ) 
{
    printf (" HelloWorld !\ n "); 
    return ; 
}
void printStringNative ( JNIEnv *env , jobject obj , jstring string )
{ 
    const char *str = env -> GetStringUTFChars ( string ,0); 
    printf ("%s!\n", str ); 
    
    return ;
}

//JNINativeMethod结构体
typedef struct {
    char *name; //本地方法名
    char *signature; // 本地方法签名
    void *fnPtr; //与本地方法相应的JNI本地函数指针
} JNINativeMethod

另外也可以直接映射本地方法,不使用JNI_Onload()函数,而在C中直接调用RegisterNatives函数,完成JNI本地函数与Java类本地方法间的映射。Android的app_process系统进程即采用这种方法,实现Android Framework的各种Java类本地方法与C函数映射。具体源码不在赘述,有兴趣可以自己研究。

九. JNI环境创建

在JNI本地函数开发过程中,我们经常可以看到一个重要的结构体JNIEnv,它是代表JNI环境的结构体。通过这个结构体我们才能调用到JNI为我们提供的丰富的API。

系统源码libnativehelper/include_jni/jni.h文件中定了很多JNI相关的结构体,其中可以看到JNIEnv的定义

//jni.h头文件
...
struct _JNIEnv;
struct _JavaVM;
typedef const struct JNINativeInterface* C_JNIEnv;
#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif
...

上面头文件代码可以看到,JNI的定义区分了C和C++,android中已经定义了宏 __cplusplus所以关注C++部分即可。C++部分可以看出JNIEnv等同于_JNIEnv结构体。_JNIEnv的定义也在jni.h头文件中

/*
 * C++ object wrapper.
 *
 * This is usually overlaid on a C struct whose first element is a
 * JNINativeInterface*.  We rely somewhat on compiler behavior.
 */
struct _JNIEnv {
    /* do not rename this; it does not seem to be entirely opaque */
    const struct JNINativeInterface* functions;

#if defined(__cplusplus)

    jint GetVersion()
    { return functions->GetVersion(this); }

    jclass DefineClass(const char *name, jobject loader, const jbyte* buf,
        jsize bufLen)
    { return functions->DefineClass(this, name, loader, buf, bufLen); }

    jclass FindClass(const char* name)
    { return functions->FindClass(this, name); }
    ...
    jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
    { return functions->GetFieldID(this, clazz, name, sig); }

    jobject GetObjectField(jobject obj, jfieldID fieldID)
    { return functions->GetObjectField(this, obj, fieldID); }
    jboolean GetBooleanField(jobject obj, jfieldID fieldID)
    { return functions->GetBooleanField(this, obj, fieldID); }
    jbyte GetByteField(jobject obj, jfieldID fieldID)
    { return functions->GetByteField(this, obj, fieldID); }
    jchar GetCharField(jobject obj, jfieldID fieldID)
    { return functions->GetCharField(this, obj, fieldID); }
    jshort GetShortField(jobject obj, jfieldID fieldID)
    { return functions->GetShortField(this, obj, fieldID); }
    jint GetIntField(jobject obj, jfieldID fieldID)
    { return functions->GetIntField(this, obj, fieldID); }
    jlong GetLongField(jobject obj, jfieldID fieldID)
    { return functions->GetLongField(this, obj, fieldID); }
    jfloat GetFloatField(jobject obj, jfieldID fieldID)
    { return functions->GetFloatField(this, obj, fieldID); }
    jdouble GetDoubleField(jobject obj, jfieldID fieldID)
    { return functions->GetDoubleField(this, obj, fieldID); }
    ....

在_JNIEnv结构体中我们可以看到有个JNINativeInterface结构体的指针变量functions,开发中使用的各种JNI函数,比如GetFieldID, GetBooleanField等等,都是调用JNINativeInterface的函数。实际上_JNIEnv是JNINativeInterface的包装类。

JNINativeInterface的具体实现:

/*
 * Table of interface function pointers.
 */
struct JNINativeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;
    void*       reserved3;

    jint        (*GetVersion)(JNIEnv *);

    jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,
                        jsize);
    jclass      (*FindClass)(JNIEnv*, const char*);
    ...
    jobject     (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);
    jobject     (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jobject     (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jboolean    (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
    jboolean    (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jboolean    (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    ....

JNINativeInterface中定义的都是函数指针,这些函数指针在哪里初始化的?
JNIEnv和线程相关,每个线程都有自己的JNIEnv对象。主线程的JNIEnv是在Zygote进程创建过程中创建的。Zygote进程中会调用函数JNI_CreateJavaVM()创建虚拟机。

// JNI Invocation interface.

extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {
  ...
  *p_env = Thread::Current()->GetJniEnv();
  *p_vm = runtime->GetJavaVM();
  return JNI_OK;
}

//thread.h
// JNI methods
JNIEnvExt* GetJniEnv() const {
    return tlsPtr_.jni_env;
}

// thread.cc 
bool Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm, JNIEnvExt* jni_env_ext) {
    
  ... 

  if (jni_env_ext != nullptr) {
    DCHECK_EQ(jni_env_ext->GetVm(), java_vm);
    DCHECK_EQ(jni_env_ext->GetSelf(), this);
    tlsPtr_.jni_env = jni_env_ext;
  } else {
    std::string error_msg;
    tlsPtr_.jni_env = JNIEnvExt::Create(this, java_vm, &error_msg);
    if (tlsPtr_.jni_env == nullptr) {
      LOG(ERROR) << "Failed to create JNIEnvExt: " << error_msg;
      return false;
    }
  }

  ScopedTrace trace3("ThreadList::Register");
  thread_list->Register(this);
  return true;
}

JNI_CreateJavaVM函数中调用Thread::Current()->GetJniEnv()创建JNIEnv,GetJniEnv函数定义在jni.h头文件中,根据源码可以看到,它直接returnt tlsPtr_.jni_env。而tlsPtr_.jni_env的创建是在Thread::Init函数中,通过JNIEnvExt::Create函数获取。这样主线程的JNIEnv环境即创建成功。
再看看其他线程的JNIEnv创建过程。Java中创建新线程调用Thread.start()方法。start调用native方法nativeCreate(),对应的本地实现Thread_nativeCreate()位于art\runtime\native下的java_lang_Thread.cc文件中:

static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, jlong stack_size,
                                jboolean daemon) {
  // There are sections in the zygote that forbid thread creation.
  Runtime* runtime = Runtime::Current();
  if (runtime->IsZygote() && runtime->IsZygoteNoThreadSection()) {
    jclass internal_error = env->FindClass("java/lang/InternalError");
    CHECK(internal_error != nullptr);
    env->ThrowNew(internal_error, "Cannot create threads in zygote");
    return;
  }

  Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
}


//Thread::CreateNativeThread 函数
void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
    ...
    pthread_create_result = pthread_create(&new_pthread,
                                           &attr,
                                           gUseUserfaultfd ? Thread::CreateCallbackWithUffdGc : Thread::CreateCallback, child_thread);
                                           
// Thread::CreateCallback  函数
void* Thread::CreateCallback(void* arg) {
Thread* self = reinterpret_cast<Thread*>(arg);
  Runtime* runtime = Runtime::Current();
  if (runtime == nullptr) {
    LOG(ERROR) << "Thread attaching to non-existent runtime: " << *self;
    return nullptr;
  }
  {
    // TODO: pass self to MutexLock - requires self to equal Thread::Current(), which is only true
    //       after self->Init().
    MutexLock mu(nullptr, *Locks::runtime_shutdown_lock_);
    // Check that if we got here we cannot be shutting down (as shutdown should never have started
    // while threads are being born).
    CHECK(!runtime->IsShuttingDownLocked());
    // Note: given that the JNIEnv is created in the parent thread, the only failure point here is
    //       a mess in InitStackHwm. We do not have a reasonable way to recover from that, so abort
    //       the runtime in such a case. In case this ever changes, we need to make sure here to
    //       delete the tmp_jni_env, as we own it at this point.
    //调用Thread Init函数
    CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM(), self->tlsPtr_.tmp_jni_env));
    ...
}

Thread_nativeCreate函数调用Thread::CreateNativeThread函数,在CreateNativeThread函数中,调用pthread_create来创建一个新线程,新线程的运行函数是CreateCallback。在CreateCallback中可以看到调用了self->Init,而这个self即为当前线程实例。Thread::Init上面已经分析,在Init函数中创建了JNIEnv对象。可以看到这个和主线程的创建过程是一致的。

上面的代码可以注意到tlsPtr_.jni_env类型是JNIEnvExt,这个JNIEnvExt和JNIEnv是什么关系呢?JNIEnvExt定义在jni_env_ext.h头文件中,打开art/runtime/jni/jni_env_ext.h头文件可以看到,其实JNIEnvExt是继承了JNIEnv类,其中定义了Create函数。

class JNIEnvExt : public JNIEnv {
    public:
  // Creates a new JNIEnvExt. Returns null on error, in which case error_msg
  // will contain a description of the error.
  static JNIEnvExt* Create(Thread* self, JavaVMExt* vm, std::string* error_msg);
    ...
}

创建JNIEnv的函数JNIEnvExt* Create的实现是在thread.cc中

JNIEnvExt* JNIEnvExt::Create(Thread* self_in, JavaVMExt* vm_in, std::string* error_msg) {
  std::unique_ptr<JNIEnvExt> ret(new JNIEnvExt(self_in, vm_in));
  if (!ret->Initialize(error_msg)) {
    return nullptr;
  }
  return ret.release();
}

JNIEnvExt::JNIEnvExt(Thread* self_in, JavaVMExt* vm_in)
    : self_(self_in),
      vm_(vm_in),
      local_ref_cookie_(jni::kLRTFirstSegment),
      locals_(vm_in->IsCheckJniEnabled()),
      monitors_("monitors", kMonitorsInitial, kMonitorsMax),
      critical_(0),
      check_jni_(false),
      runtime_deleted_(false) {
  MutexLock mu(Thread::Current(), *Locks::jni_function_table_lock_);
  check_jni_ = vm_in->IsCheckJniEnabled();
  functions = GetFunctionTable(check_jni_);
  unchecked_functions_ = GetJniNativeInterface();
}

//GetFunctionTable
const JNINativeInterface* JNIEnvExt::GetFunctionTable(bool check_jni) {
  const JNINativeInterface* override = JNIEnvExt::table_override_;
  if (override != nullptr) {
    return override;
  }
  return check_jni ? GetCheckJniNativeInterface() : GetJniNativeInterface();
}

在JNIEnvExt::Create函数中new了一个JNIEnvExt对象。而在JNIEnvExt构造函数中functions通过GetFunctionTable(check_jni_)函数获得。functions变量在上面的介绍中知道它是JNINativeInterface*类型的指针。GetFunctionTable函数中,如果check_jni为true,调用GetCheckJniNativeInterface()并返回,如果是false则GetJniNativeInterface()并返回。check_jni用于JNI检查,用于调试发现JNI问题。看看GetJniNativeInterface()函数:

const JNINativeInterface* GetJniNativeInterface() {
  // The template argument is passed down through the Encode/DecodeArtMethod/Field calls so if
  // JniIdType is kPointer the calls will be a simple cast with no branches. This ensures that
  // the normal case is still fast.
  return Runtime::Current()->GetJniIdType() == JniIdType::kPointer
             ? &JniNativeInterfaceFunctions<false>::gJniNativeInterface
             : &JniNativeInterfaceFunctions<true>::gJniNativeInterface;
}

//gJniNativeInterface变量定义
template<bool kEnableIndexIds>
struct JniNativeInterfaceFunctions {
  using JNIImpl = JNI<kEnableIndexIds>;
static constexpr JNINativeInterface gJniNativeInterface = {
    nullptr,  // reserved0.
    nullptr,  // reserved1.
    nullptr,  // reserved2.
    nullptr,  // reserved3.
    JNIImpl::GetVersion,
    JNIImpl::DefineClass,
    JNIImpl::FindClass,
    JNIImpl::FromReflectedMethod,
    JNIImpl::FromReflectedField,
    JNIImpl::ToReflectedMethod,
    JNIImpl::GetSuperclass,
    JNIImpl::IsAssignableFrom,
    JNIImpl::ToReflectedField,
    JNIImpl::Throw,
    JNIImpl::ThrowNew,
    ...

GetJniNativeInterface()函数定义在jni_internal.cc中,其返回gJniNativeInterface变量。gJniNativeInterface对应的是JNINativeInterface结构体。JNIImpl是JNI的别名,可以看到具体代码是实现是在JNI类中。JNI类也是在jni_internal.cc文件中

template <bool kEnableIndexIds>
class JNI {
 public:
  static jint GetVersion(JNIEnv*) {
    return JNI_VERSION_1_6;
  }

  static jclass DefineClass(JNIEnv*, const char*, jobject, const jbyte*, jsize) {
    LOG(WARNING) << "JNI DefineClass is not supported";
    return nullptr;
  }

  static jclass FindClass(JNIEnv* env, const char* name) {
    CHECK_NON_NULL_ARGUMENT(name);
    Runtime* runtime = Runtime::Current();
    ClassLinker* class_linker = runtime->GetClassLinker();
    std::string descriptor(NormalizeJniClassDescriptor(name));
    ScopedObjectAccess soa(env);
    ObjPtr<mirror::Class> c = nullptr;
    if (runtime->IsStarted()) {
      StackHandleScope<1> hs(soa.Self());
      Handle<mirror::ClassLoader> class_loader(hs.NewHandle(GetClassLoader<kEnableIndexIds>(soa)));
      c = class_linker->FindClass(soa.Self(), descriptor.c_str(), class_loader);
    } else {
      c = class_linker->FindSystemClass(soa.Self(), descriptor.c_str());
    }
    return soa.AddLocalReference<jclass>(c);
  }
  ...

这就解开了上面提的问题“JNINativeInterface中定义的都是函数指针,这些函数指针在哪里初始化的?”这个问题,实际的实现类是JNI类。

到这里,终于搞清了JNIEnv的创建和初始化流程。总结起来比较简单,创建线程后在线程的Init方法中创建并初始化JNIEnv环境变量,最终JNINativeInterface的函数指针是在JNI类中实现。

十. 源码路径

JNINativeInterface:libnativehelper/include_jni/jni.h

JNIEnvExt:art/runtime/jni/jni_env_ext.h
art/runtime/jni/jni_env_ext.cc

thread.cc: art/runtime/thread.cc

GetCheckJniNativeInterface(): art/runtime/jni/check_jni.cc

GetJniNativeInterface(): art/runtime/jni/jni_internal.cc

JNI:art/runtime/jni/jni_internal.cc

原文链接:https://juejin.cn/post/7261509144237310013 作者:lark

(0)
上一篇 2023年7月31日 上午10:16
下一篇 2023年7月31日 上午10:26

相关推荐

发表回复

登录后才能评论