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 类型

1 . 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;
//......
复制代码 

2 . 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得到

   jclass FindClass(const char* name){}
复制代码 

如：java/lang/String 参数name是指Java类的名称 jclass类型用来表示Java类 在JNI中，经常要通过jclass来得到Java类的成员变量和方法

FindClass函数的原型如下：

参数methodID是指Java类的构造函数

   jmethodID GetMethodID(jclass clazz, const char* name, const char* sig){}
jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
复制代码 

一个类的构造方法经编译后会转换为 方法 如果要得到一个Java类的构造函数，使用GetMethodID时，传入的参数必须是 才可以 调用一个Java对象的方法或者存取一个Java对象的域变量前，要先获得对应的Id，可用的函数如下：

我们看一个生成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对象

下面是简单的分析过程，这是主线程哟：

1 . 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;
    }
    //...... 省略部分内容
}
复制代码 

2 . 调用到了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;
}
复制代码 

3 . 又调用到了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 系统 - Android 的 JNI的详细内容...