JNI 的作用
JNI
是Java Native Interface
的缩写。JNI
不是Android
专有的东西,它是从Java
继承而来的,但是在Android
中,JNI
的作用和重要性大大增强了。
Android
作为一种嵌入式操作系统,有大量驱动、硬件相关的功能必须在native层
实现,另外一些注重性能、功耗的功能使用C/C++
来实现也优于用Java
来实现。因此,在Android
的开发中,无论是应用级的开发,还是系统级的开发都离不开JNI
。Android
在编译、应用打包和安装、程序装载等各方面都对JNI
进行了有力的支持。
Java
语言的执行,离不开虚拟机,因此,当需要在Java
代码中调用C/C++
层的函数时,需要告诉虚拟机哪个方法代表本地的函数,以及在哪里能找到这个函数,反之也类似。
- 从
Java
到C/C++
建立的是函数间的关联 - 而从
C/C++
到Java
,必须先得到Java对象
的引用,才能调用该对象的方法
另外,请记住,一旦使用 JNI
,Java
程序就丧失了 Java 平台
的两个优点:
- 程序不再跨平台。要想跨平台,必须在不同的系统环境下重新编译本地语言 部分。
- 程序不再是绝对安全的,本地代码的不当使用可能导致整个程序崩溃。
JNI 用法介绍
JNI 头文件位于
libnativehelper/include_jni/jni.h
从Java
到C/C++
装载 JNI
动态库
为了使用JNI
,在调用本地方法前必须把C/C++
代码所编译生成的动态库
装载到进程的内存空间中。
装载库文件使用的是System
类的LoadLibrary
方法,原型如下:
public static void loadLibrary (String libname)
loadLibrary
方法的参数是动态库
文件名称的一部分。Android JNI
动态库必须以lib
开头,这里传入的参数是去掉前缀lib
,以及后缀.so
的中间部分。
例如:库文件名为libmyjni.so
,装载库的语句要写成loadLibrary("myjni")
。为什么不使用全文件名呢?
JNI
原本是Java
的产物,Java
希望代码能够夸平台使用- 不同平台
动态库
的后缀并不一样Linux
下是.so
Windows
下是.dll
- 因此,为了适应不同的平台,这里传入的参数去掉了和系统相关的部分
调用loadLibrary
方法不需要指定库文件所在的路径,Android
会在几个系统目录下查找动态库
。
为了保证调用native方法前所需要的动态库已经加载,loadLibrary
的调用位置一般放在类的static块
中,这样在类加载
的时候就能执行装载语句了。
定义native
方法
在Java
类中定义native
方法很简单,在方法前面加上native
关键字就可以了,例如:
private native void init();
在native
方法中,可以使用任何类型作为参数,包括:
- 基础数据类型
- 数组类型
- 复杂对象
native
方法在使用上和普通的Java
方法没有区别,
编写JNI 动态库
JNI 动态库
和非 JNI 动态库
的区别是:JNI 动态库
中定义了一个名为JNI_OnLoader
的函数,这个函数在动态库加载后会被系统调用,用于完成JNI 函数
的注册。
JNI_OnLoader
函数的原型如下:
jint JNI_OnLoad(JavaVM* vm, void*)
在JNI_OnLoader
函数中,最重要的一件事就是调用registerNativeMethods
函数完成动态库
中JNI 函数
的注册。
所谓注册
,就是通过一张表把Java类
中定义的native方法
和本地C函数
联系起来,这样虚拟机在解析Java类
中的native方法
时就能查找到对应的C函数
。
随便从源码中找个例子来加深下印象:
static JNINativeMethod HdcpJNIMethods[] = {
/* name, signature, funcPtr */
{
"aml_init_unifykeys", "()Ljava/lang/String;", (void*) aml_init_unifykeys },
{
"aml_key_query_exist", "(Ljava/lang/String;)Ljava/lang/String;", (void*) aml_key_query_exist },
{
"aml_key_get_name", "()Ljava/lang/String;", (void*) aml_key_get_name },
};
JNIEXPORT jint
JNI_OnLoad(JavaVM* vm, void* reserved)
{
//......
ret = android::AndroidRuntime::registerNativeMethods(env,
FINSKY_CLASS_NAME, HdcpJNIMethods, NELEM(HdcpJNIMethods));
//......
}
registerNativeMethods
函数的原型是
int registerNativeMethods(C_JNIEnv* env, const char* className,
const JNINativeMethod* gMethods, int numMethods)
参数中:
-
第二个参数是指声明
native方法
的Java类
的全限定名 -
第三个参数是
JNINativeMethod
类型的数组,类型定义如下:
typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
JNINativeMethod
类型中:
name
是指Java类
中的native方法
的名称signature
是指native方法
的参数签名fnPtr
是指native方法
对应的本地函数指针- 虽然这里
fnPtr
是一个void
类型的函数指针 - 但是,
JNI
中对于函数的定义也是有要求的 - 由于
native
函数必须是可变参数类型的 - 所以先试用
void
类型的函数指针 - 调用时再根据参数做强制类型转换
- 虽然这里
native方法
原型要求如下:
返回类型 函数名(JNIEnv *env,jobject obj, ......)
- 第一个参数是
JNI环境
- 第二个参数是指调用类的
Java对象
- 后面省略号才是具体的
方法参数
举个栗子:
static jstring aml_key_query_exist(JNIEnv *env, jobject obj, jstring keyName)
参数签名
native方法
的参数签名
使用了一些缩写符号
来表示参数类型,这些符号都是Java语言
规定的。
签名
由参数
和返回值
组成:
参数
必须由小括号括起来- 没有参数时需使用一对空括号
()
- 多个参数间无需分隔符
- 没有参数时需使用一对空括号
返回值
跟在参数
后面
在JNI
环境中,定义了一些对象来和Java
中的基本类型相匹配,我们看下对应表:
参数签名 | Java类型 | JNI类型 |
---|---|---|
Z | boolean | jboolean |
C | char | jchar |
B | byte | jbyte |
S | short | jshort |
I | int | jint |
J | long | jlong |
F | float | jfloat |
D | double | jdouble |
参数签名
中一维数组
的表示方法是:在基本类型
符号前面加上符号[
二维数组
也就是[[
参数签名
中复杂类型的签名格式是L
,加上全限定类名
,再加上;
举例:
(I)V
:参数为整型
,无返回值([IZ)I
:参数为一维整型数组
和布尔类型
,返回值为整型
(Ljava/lang/String;)Ljava/lang/String;
:参数为字符串
,返回值为字符串
使用 JNI 类型
Java
的基本类型都是无符号的,但是对应的JNI类型
并不都是无符号的,我们看下JNI类型
的定义:
//基本类型的定义,可以像Java中的基本类型一样,直接使用
typedef uint8_t jboolean; /* unsigned 8 bits */
typedef int8_t jbyte; /* signed 8 bits */
typedef uint16_t jchar; /* unsigned 16 bits */
typedef int16_t jshort; /* signed 16 bits */
typedef int32_t jint; /* signed 32 bits */
typedef int64_t jlong; /* signed 64 bits */
typedef float jfloat; /* 32-bit IEEE 754 */
typedef double jdouble; /* 64-bit IEEE 754 */
//数组类型的定义
//。。。只是定义的jobject的一个别名
//嗯,impressive
typedef void* jobject;
typedef jobject jclass;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray jobjectArray;
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
//......
JNI
的数组类型
,从上面的定义可以看到,其实只是jobject
通过typedef
定义出来的别名。那我们想操作数组怎么办呢?
在JNIEnv
中定义了很多很多
和数组相关的操作函数,我们看几个示例:
struct _JNIEnv {
//......
jsize GetArrayLength(jarray array){
}
//......
jint* GetIntArrayElements(jintArray array, jboolean* isCopy){
}
//......
void ReleaseIntArrayElements(jintArray array, jint* elems,jint mode){
}
}
typedef _JNIEnv JNIEnv;
有了上面这几个方法,对于一个数组来说,我们就可以:
- 通过
GetArrayLength
查看数组的长度 - 通过
GetIntArrayElements
取出数组指针,并转换成jint
类型 - 通过
ReleaseIntArrayElements
释放掉不需要的数组内存
jstring
的本质也是jobject
类,但是使用频率高,所以单独定义了操作函数,相关的方法包括:
// UTF-8 字符相关的操作
jsize GetStringUTFLength(jstring string){
}
const char* GetStringUTFChars(jstring string, jboolean* isCopy){
}
void ReleaseStringUTFChars(jstring string, const char* utf){
}
//unicode 字符相关的操作
jsize GetStringLength(jstring string){
}
const jchar* GetStringChars(jstring string, jboolean* isCopy){
}
void ReleaseStringChars(jstring string, const jchar* chars){
}
- 如果一次只取一个数组元素,可以使用下面的函数
jobject GetObjectArrayElement(jobjectArray array, jsize index){
}
从C/C++
到Java
生成 Java对象
在JNIEnv
中生成一个Java对象
可以使用函数NewObject
jobject NewObject(jclass clazz, jmethodID methodID, ...){
}
- 参数
clazz
是指Java类对象
,可以通过函数FindClass
得到FindClass
函数的原型如下:
jclass FindClass(const char* name){ }
- 参数
name
是指Java类
的名称- 如:
java/lang/String
- 如:
jclass
类型用来表示Java类
- 在
JNI
中,经常要通过jclass
来得到Java类
的成员变量和方法
- 参数
methodID
是指Java类
的构造函数- 调用一个Java对象的方法或者存取一个Java对象的域变量前,要先获得对应的Id,可用的函数如下:
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig){ } jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
- 如果要得到一个
Java类
的构造函数,使用GetMethodID
时,传入的参数必须是<init>
才可以- 一个类的
构造方法
经编译后会转换为<init>
方法
- 一个类的
我们看一个生成Intent对象的例子:
jclass clazz = env->FindClass("android/content/Intent");
jmethodID method = env->GetMethodID(clazz, "<init>", "Ljava/lang/String;");
jstring action = env->NewStringUTF("android.init.action.MAIN");
jobject intent = env->NewObject(clazz,method,action);
调用 Java 类的方法
我们看下JNIEnv
提供的调用Java
类中的方法的函数:
- 对象方法
jobject CallObjectMethod(JNIEnv*, jobject, jmethodID, ...);
jboolean CallBooleanMethod(JNIEnv*, jobject, jmethodID, ...);
jbyte CallByteMethod(JNIEnv*, jobject, jmethodID, ...);
jchar CallCharMethod(JNIEnv*, jobject, jmethodID, ...);
jshort CallShortMethod(JNIEnv*, jobject, jmethodID, ...);
jint CallIntMethod(JNIEnv*, jobject, jmethodID, ...);
jlong CallLongMethod(JNIEnv*, jobject, jmethodID, ...);
jfloat CallFloatMethod(JNIEnv*, jobject, jmethodID, ...);
jdouble CallDoubleMethod(JNIEnv*, jobject, jmethodID, ...);
void CallVoidMethod(JNIEnv*, jobject, jmethodID, ...);
- 类方法
jobject CallStaticObjectMethod(JNIEnv*, jobject, jmethodID, ...);
jboolean CallStaticBooleanMethod(JNIEnv*, jobject, jmethodID, ...);
jbyte CallStaticByteMethod(JNIEnv*, jobject, jmethodID, ...);
jchar CallStaticCharMethod(JNIEnv*, jobject, jmethodID, ...);
jshort CallStaticShortMethod(JNIEnv*, jobject, jmethodID, ...);
jint CallStaticIntMethod(JNIEnv*, jobject, jmethodID, ...);
jlong CallStaticLongMethod(JNIEnv*, jobject, jmethodID, ...);
jfloat CallStaticFloatMethod(JNIEnv*, jobject, jmethodID, ...);
jdouble CallStaticDoubleMethod(JNIEnv*, jobject, jmethodID, ...);
void CallStaticVoidMethod(JNIEnv*, jobject, jmethodID, ...);
存取Java类的域变量
在得到了成员变量
的ID
后,对于变量的读和写,JNIEnv
分别定义了对应的函数:
- 非静态成员变量,读相关的部分函数
jobject GetObjectField(jobject obj, jfieldID fieldID){
}
jboolean GetBooleanField(jobject obj, jfieldID fieldID){
}
jint GetIntField(jobject obj, jfieldID fieldID){
}
//......
- 非静态成员变量,写相关的部分函数
void SetObjectField(jobject obj, jfieldID fieldID, jobject value){
}
void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value){
}
void SetIntField(jobject obj, jfieldID fieldID, jint value){
}
//......
- 静态成员变量,读相关的部分函数
jobject GetStaticObjectField(jobject obj, jfieldID fieldID){
}
jboolean GetStaticBooleanField(jobject obj, jfieldID fieldID){
}
jint GetStaticIntField(jobject obj, jfieldID fieldID){
}
//......
- 静态成员变量,写相关的部分函数
void SetStaticObjectField(jobject obj, jfieldID fieldID, jobject value){
}
void SetStaticBooleanField(jobject obj, jfieldID fieldID, jboolean value){
}
void SetStaticIntField(jobject obj, jfieldID fieldID, jint value){
}
//......
JNI 环境
结构体 JNIEnv
JNIEnv
是代表JNI
环境的结构体,定义如下:
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
定义:
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); }
//......
#endif /*__cplusplus*/
结构体中的函数有调用了成员变量functions
的函数,functions
是指向结构体JNINativeInterface
的指针,JNINativeInterface
的定义如下:
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*);
//......
}
JNINativeInterface
中定义的都是函数指针,这些函数指针在哪里实现的呢?
- 书中的讲解还是用的
dalvik虚拟机
,所以这部分就不记录了 - 通过
grep
,在art/runtime/jni_internal.cc
中找到了函数实现
我们看下jni_internal.cc
的代码片段:
- 定义了一个
JNI
类,并按照JNINativeInterface
中的函数名来实现
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) {
//......省略实现
}
//......省略JNINativeInterface中其他方法
}
- 创建一个
JNINativeInterface
的实例gJniNativeInterface
const JNINativeInterface gJniNativeInterface = {
nullptr, // reserved0.
nullptr, // reserved1.
nullptr, // reserved2.
nullptr, // reserved3.
JNI::GetVersion,
JNI::DefineClass,
JNI::FindClass,
//......省略其他参数
}
这样,JNINativeInterface
的函数实现我们就找到了,在类JNI
中。
JNIEnv 的创建和初始化
JNIEnv
是JNI
的使用环境。JNIEnv
对象是和线程绑定在一起的,那我们考虑几个问题:
- 当我们在
Java线程
中调用native层
的JNI
函数时,线程所属的JNIEnv
对象已经生成了吗? - 如果生成了,在什么时候生成的呢?
熟悉 JavaVM 的结构
在前面已经了解了JNI_OnLoad
函数
- 它会传递一个
JavaVM
的指针作为参数 - 通过
JavaVM
的getEnv
函数可以获得JNIEnv
对象的指针 JavaVM
其实就是_JavaVM
typedef _JNIEnv JNIEnv; typedef _JavaVM JavaVM;
既然这样,我们先看下_JavaVM
的结构:
struct _JavaVM {
const struct JNIInvokeInterface* functions;
#if defined(__cplusplus)
jint DestroyJavaVM()
{
return functions->DestroyJavaVM(this); }
jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)
{
return functions->AttachCurrentThread(this, p_env, thr_args); }
jint DetachCurrentThread()
{
return functions->DetachCurrentThread(this); }
jint GetEnv(void** env, jint version)
{
return functions->GetEnv(this, env, version); }
jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)
{
return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }
#endif /*__cplusplus*/
};
struct JNIInvokeInterface {
void* reserved0;
void* reserved1;
void* reserved2;
jint (*DestroyJavaVM)(JavaVM*);
jint (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);
jint (*DetachCurrentThread)(JavaVM*);
jint (*GetEnv)(JavaVM*, void**, jint);
jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
};
_JavaVM
中定义了一些和虚拟机生命周期相关的方法- 方法的实现是通过调用的
JNIInvokeInterface functions
的函数
这部分就和_JNIEnv
的函数实现是一样的了。同样的,通过查找在art/runtime/java_vm_ext.cc
中找到了函数实现,如下:
//初始化 JNIInvokeInterface 部分
const JNIInvokeInterface gJniInvokeInterface = {
nullptr, // reserved0
nullptr, // reserved1
nullptr, // reserved2
JII::DestroyJavaVM,
JII::AttachCurrentThread,
JII::DetachCurrentThread,
JII::GetEnv,
JII::AttachCurrentThreadAsDaemon
};
// 函数实现部分
class JII {
public:
static jint DestroyJavaVM(JavaVM* vm) {
//......省略实现
}
static jint AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
//......省略实现
}
static jint AttachCurrentThreadAsDaemon(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
//......省略实现
}
static jint DetachCurrentThread(JavaVM* vm) {
//......省略实现
}
static jint GetEnv(JavaVM* vm, void** env, jint version) {
//......省略实现
}
};
主线程下的初始化–ART的启动函数
这里并不会深入讲解,只是为了串联起JNI的一些相关知识。
Android 应用都是从Zygote
进程fork
而来的,后面会详细讲解Zygote
进程。在这里我们需要了解的是
Zygote
进程中会执行ART
的start
方法ART
的start
方法会初始化JNIEnv
对象
下面是简单的分析过程,这是主线程
哟:
ART
的启动函数是在frameworks/base/core/jni/AndroidRuntime.cpp
中,我们简单看下:
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
//...... 省略部分内容
JNIEnv* env;
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
//...... 省略部分内容
}
- 调用到了
startVm
函数,我们看下具体实现:
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
{
// 大约有500多行的参数配置代码
// 以为走错片场了。。。
if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");
return -1;
}
return 0;
}
- 又调用到了
JNI_CreateJavaVM
,来看看:
extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {
//...... 省略部分代码
Runtime* runtime = Runtime::Current();
bool started = runtime->Start();
if (!started) {
delete Thread::Current()->GetJniEnv();
delete runtime->GetJavaVM();
LOG(WARNING) << "CreateJavaVM failed";
return JNI_ERR;
}
//请看这里,赋值了有木有,算是找到根儿了
//JNIEnv 对象是在 Thread 类中实例化的
*p_env = Thread::Current()->GetJniEnv();
// JavaVM 对象是在 Runtime 中实例化的
*p_vm = runtime->GetJavaVM();
return JNI_OK;
}
到这里,主线程
就梳理的差不多了:
- 对于
主线程
来说,在虚拟机启动的时候,JNIEnv
就已经创建好了
普通线程下的初始化
主线程是在虚拟机启动时,在Thread
类中初始化了JNIEnv
对象。那如果是Java中新创建的线程呢?
- 我们知道
Java
中线程的启动通过start()
方法 start()
方法执行的是native
函数nativeCreate()
nativeCreate()
调用的是Thread_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) {
//...... 省略部分
Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
}
CreateNativeThread
函数中将使用Linux
的线程函数
来创建一个新线程。代码如下:
void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
//...... 省略部分
pthread_create_result = pthread_create(&new_pthread,
&attr,
Thread::CreateCallback,
child_thread);
//...... 省略部分
}
这个新线程的运行函数是Thread::CreateCallback
,我们再来看下它的实现:
void* Thread::CreateCallback(void* arg) {
Thread* self = reinterpret_cast<Thread*>(arg);
Runtime* runtime = Runtime::Current();
//......
{
//......
CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM(), self->tlsPtr_.tmp_jni_env));
self->tlsPtr_.tmp_jni_env = nullptr;
}
//......
}
Thread::CreateCallback
调用了Thread
的Init
函数
bool Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm, JNIEnvExt* jni_env_ext) {
//......
tlsPtr_.jni_env = JNIEnvExt::Create(this, java_vm, &error_msg);
thread_list->Register(this);
//......
}
这里会新创建一个JNIEnv
对象。
JNIEnv 对象的初始化总结
对于JNIEnv
对象的初始化就两点:
- 主线程中的
JNIEnv
对象在创建虚拟机时就已经建好了 - Java 中新建线程的
JNIEnv
对象是在该线程运行时建立的,并在线程结束时释放
JNI 中的异常处理
在 JNI 中检查Java层产生的异常
首先要明确的是,Android的C++层
不支持try-catch
机制
- 如果
JNI
调用Java层
的方法时发生了异常JNI调用
会正常返回- 但是,如果继续调用其他
JNI函数
,可能会导致进程崩溃
为此,JNI
中提供了一组函数来检查Java方法
是否抛出了异常,方法原型如下:
// 检查是否有异常发生
jthrowable ExceptionOccurred();
// 打印输出异常信息
void ExceptionDescribe();
// 清除异常
void ExceptionClear();
在 JNI 中抛出异常
如果要在JNI
中抛出异常,JNIEnv
也提供了两个函数,如下所示:
jint Throw(jthrowable obj);
jint ThrowNew(jclass clazz, const char* message);
Throw
函数用来抛出一个已存在的异常,通常用于捕获后再次抛出ThrowNew
函数用来新生成一个异常并向外抛出- 参数
clazz
是指Java
中的Exception类
及其派生的类对象
- 参数
在JNIHelp
中也定义了几个函数来方便抛出一些常见的异常,具体包括:
// 抛出 java/lang/NullPointerException 空指针异常
inline int jniThrowNullPointerException(JNIEnv* env, const char* msg);
// 抛出 java/lang/RuntimeException 运行时异常
inline int jniThrowRuntimeException(JNIEnv* env, const char* msg);
// 抛出 java/lang/IOException IO异常
inline int jniThrowIOException(JNIEnv* env, int errnum);
JNI 中的引用
在JNI
中有三种引用:本地引用(LocalReference)
、全局引用(GlobalReference)
、弱全局引用(WeakGlobalReference)
JNI
位于C/C++
和Java
之间,虽然JNI
函数的代码使用C/C++
语言编写,但是通过JNI
创建的Java对象
和在Java
世界里创建的一样,都会被虚拟机进行垃圾回收。
本地引用(LocalReference)
在JNI
本地函数中生成的Java对象
,它们的生命周期应该在函数退出时结束。
虚拟机如何保证呢?
- 每个
Java线程
都有一张本地引用(LocalReference)
表,虚拟机在进行内存回收时不会回收表里的对象。 - 而在创建对象时,
JNIEnv
隐式地把这些Java对象
加入到本地引用(LocalReference)
表中了。 - 本地函数执行完后再将其从表中移除。这样虚拟机会在下次垃圾回收时将其释放。
我们也可以显式操作:
jobject NewLocalRef(jobject ref);
void DeleteLocalRef(jobject localRef);
全局引用(GlobalReference)
全局引用(GlobalReference)
的对象需要显式的创建、删除。虚拟机不会回收。
JNIEnv
提供了两个函数:
jobject (jobject obj);
void DeleteGlobalRef(jobject globalRef);
NewGlobalRef
做了这几个事情:- 先将
Java对象
从本地引用(LocalReference)
表中删除 - 然后将该对象放到
全局引用(GlobalReference)
表中
- 先将
DeleteGlobalRef
做了:- 将
Java对象
从全局引用(GlobalReference)
表中删除 - 此时不会立刻回收对象,等到下次垃圾回收时才会释放
- 将
弱全局引用(WeakGlobalReference)
弱全局引用(WeakGlobalReference)
引用下的对象如果没有其他的引用类型时,下次垃圾回收时会被回收掉。
相关的操作函数是:
jweak NewWeakGlobalRef(jobject obj);
void DeleteWeakGlobalRef(jweak obj);
启动CheckJNI
应用程序内部如果JNI部分发生了错误,通常情况下不会打印太多的log。
因此,Android
定义了一个名为debug.checkjni
的属性:
- 当值为1时,系统的
JNI函数
会对调用的参数进行更多的检查- 同样的会增加资源消耗,降低执行效率
- 默认为0
设置方式:
setprop debug.checkjni 1
总结
本篇只是对JNI
使用上的技巧进行了比较简单的总结。由于主动使用的频率不怎么高,权当一些补充知识啦。
本人在想,如果深究JNI原理
上的事情可能就会涉及:
- 动态库的编译、装载
- 本地方法的执行过程
- 虚拟机本地方法栈相关
等等知识吧。
哈哈哈,JNI
先了解到这里了,终于知道JNI
中的env
是咋来的了!
下一篇学习Android 的同步和消息机制
,加油!