JNI 原理进阶

最新推荐文章于 2022-05-30 17:56:29 发布
最新推荐文章于 2022-05-30 17:56:29 发布
阅读量882 收藏 2
点赞数
分类专栏： Android 文章标签： jvm jni android JNIEnv JavaVm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zsl_oo7/article/details/71081291
版权
这篇博客详细介绍了JNI的原理，包括Java如何加载库、JNI函数的命名规则、JNIEnv结构体及其在C和C++中的差异。还探讨了动态注册的概念、原理和在Android中的实现，以及如何在JNI层操作Java层的方法。最后，通过一个从无到有的JNI应用实例，展示了如何使用The Invocation API启动JVM并调用Java方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

回顾

JNI 要点

  1. Java 要 load 库
  2. Java 要把方法声明为 native 的
  3. C 语言实现 Java 的 native 方法时，函数名有固定形式，可以用 javah 生成头文件得到函数名
  4. Java 调用 C 函数时，JVM 会自动传两个参数下去： 分别是 JNIEnv * 和 jobject 类型的

层：Java -> JNI -> Native

  • 分三层
    • 最上面是 Java 层
    • 中间是JIN层，C语言编写，以.so形式存在
    • 最下是Native层，C语言编写，以.so形式存在
  • 举例
    • Java（MediaScanner） —> JIN（libmedia_jin.so） —> Native（libmedia.so）
  • jni 层和 Native 层虽然都是 C/C++ 写的，但还是有区别的：
    • Native 层完全不知道有 Java 层的存在，是完完全全的C/C++语言写程序。
    • JNI 层的C/C++函数的第一个参数都是 JNIEnv* env，函数可以通过这个参数跟Java层交互。

JNIEnv

  • Java 传给 C 的第一个参数是 JNIEnv* 类型的，下面我们就看看 JNIEnv 是什么

JNIEnv 是什么

  • JNIEnv 是个结构体，这个结构体里，全都是函数指针，一共有300个左右。
  • 这些函数指针形如：
jclass      (*FindClass)(JNIEnv*, const char*);
jint        (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
void        (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
void        (*SetIntField)(JNIEnv*, jobject, jfieldID, jint);
jbyteArray    (*NewByteArray)(JNIEnv*, jsize);
const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
  • JNIEnv* 是 java 虚拟机传的
  • 也就是说是 java 虚拟机初始化了一个 JNIEnv 结构体，把300个函数指针都初始化了。
  • 但函数指针指向的都是C的函数，所以这是Java虚拟机干的事儿。Java虚拟机作为Java世界和C世界的桥梁，这也是体现之处。
  • 当你愉快的调用 (*env)->FindClass(env, "java/lang/String") 时，虽然这是一个C函数，但它是 java 虚拟机初始化的。
  • 总之， JNIEnv 是 Java 虚拟机为 C 层准备的一系列函数的集合。

C 和 C++ 中 JNIEnv 的区别

  • jni 层函数的第一个参数都是 JNIEnv* env， 无论C还是C++
  • 但是这个 JNIEnv 对于C和C++是不同的，看一下 jni.h 中的定义(来自 NDK r13b)：
#if defined(__cplusplus)
/* 在C++中，JNIEnv 等同于 _JNIEnv，而_JNIEnv是一个结构体，一会儿下面会有代码 */
typedef _JNIEnv JNIEnv;     
typedef _JavaVM JavaVM;
#else
/* 在C语言中，JNIEnv 是个指向结构体的指针，指向的是 JNINativeInterface 类型的结构体 */
typedef const struct JNINativeInterface* JNIEnv;   
typedef const struct JNIInvokeInterface* JavaVM;
#endif

...

// 里面定义的全是函数指针 
struct JNINativeInterface 
{
    jclass  (*FindClass)(JNIEnv*, const char*);
}

...

// 里面定义的全是函数指针 
struct _JNIEnv 
{
    // C++ 的 JNIEnv 是个 wrapper，其函数调用还是 JNINativeInterface 的函数
    const struct JNINativeInterface_ *functions;
    jclass FindClass(const char *name) {
        return functions->FindClass(this, name);
    }
}
  • 区别1：对于C语言，使用 (*env)-> 来调用函数；对于 C++ 用 env->。
  • 区别2：对于C语言，使用 (*env)->xxx(env, ...) 来调用函数；对于 C++ 用 env->()，即 C 语言第一个参数还要把 env 写上去。

动态注册

什么是动态注册

  • 目前我们知道，JNI 层的函数名，一定得叫 Java_包名_类名_函数名
  • 这是因为，当 Java 调用 native 方法时，会去 so 库里搜索，搜索的函数名就是这么约定的。
  • 如果不按这种规则命名，也有方法能让 Java 找到对应的 C/C++ 函数，就是动态注册
  • 动态注册是 JNI 层主动告诉 Java 层函数对应关系，让 Java 层不必去库里搜索。
  • 动态注册除了有缩短函数名，不借助 javah 工具这两个好处，还有提升效率的好处，因为可以避免搜索。

动态注册的原理

  • Java 在调用 C/C++ 之前，肯定要加载 C/C++ 的库，即 System.loadLibrary()
  • 在加载库的时候，JVM 会去被加载的库中寻找函数 JNI_OnLoad(JavaVM* jvm, void* reserved)，如果找到了就调用它。它是一个 C/C++ 函数，工作在 JNI 层。
  • 我们就在这个函数里实现动态注册。即我们在 JNI 代码里实现这个函数，在函数体内完成动态注册。

JNI_OnLoad()

  • 在实现这个函数之前，先来看看它的参数：JNI_OnLoad(JavaVM* jvm, void* reserved)
  • 第二个参数从名字就能看出来，是保留参数，暂不讨论。
  • 第一个参数是 JavaVM* 类型的。而普通的 JNI 函数的第一个参数都是 JNIEnv* 类型的。

JavaVM 和 JNIEnv

  • JavaVM 是进程相关的，JNIEnv 是线程相关的
  • 在 Android 里，每个进程只有一个 JavaVM（DalvikVM） 的实例
  • Android 中每当一个 Java 线程第一次要调用本地 C/C++ 代码时，Dalvik 虚拟机实例会为该 Java 线程产生一个 JNIEnv* 指针;
  • Java 每条线程在和 C/C++ 相互调用时，JNIEnv* 是相互独立的，互不干扰，这就提升了并发执行时的安全性;
  • 当本地的 C/C++ 代码想获得当前线程所想要使用的 JNIEnv 时，可以使用 Dalvik VM 对象的 JavaVM* jvm->GetEnv() 方法,该方法即会返回当前线程所在的 JNIEnv*。
    JNI_OnLoad(JavaVM* jvm, void* reserved) 会把虚拟机对象传递到 JNI 层，这几乎是整个 JNI so 库唯一一次获得 JVM 指针的机会。
    所以一般正经的 Native Code 的 jni 层，都会实现 JNI_OnLoad() 函数，并且在函数里用全局变量把 JavaVM* 保存下来，以便以后使用。

关于Android

  • 可以不准确的理解为：一个 Android app 就是一个 Android Linux 上的进程
  • 在 Android 里，可以简单的理解为：一个进程对应一个 Dalvik 虚拟机。Java 的 dex 字节码和 c/c++ 的 so 库同时运行这个进程之内。
  • Dalvik 虚拟机当然已经实现了JNI标准，所以在 Dalvik 虚拟机加载 so 库时，会先调用 JNI_Onload()

动态注册的实现

  • Java 虚拟机已经准备好了函数，专门用于动态注册：(*env)->RegisterNatives(env, clazz, gMethods, numMethods)
  • 我们在 JNI_OnLoad() 里调用它即可
  • 其中 gMethods 是一个数组，数组里放的都是 JNINativeMethod 类型的变量
  • JNINativeMethod 这个结构体如下：
typedef struct{
    //Java 中native函数名，不用包含路径，比如 processFile
    const char* name;
    //Java 函数的签名信息，用字符串表示，是参数类型和返回值类型的组合
    const char* signature;
    //JNI 层对应的函数的指针
    void* fnPtr;
}JNINativeMethod;
  • 这个结构体就是把 Java 层的函数名和 JNI 层的函数指针对应起来的
  • 所以，把实现了的 Java 层的函数的指针和 Java 层函数名对应写好，封装到这个结构体里
  • 再把所有这样的结构体放到数组 gMethods 里
  • 就可以用 RegisterNatives() 进行函数注册了
  • 因为 JNINativeMethod 结构体里只写 Java 里的函数名，不包含路径，所以不知道这个函数是哪个类的
  • 所以 RegisterNatives() 需要一个参数 clazz，这是 jclass 类型的，代表着java类
  • 注册过的函数就有了对应关系了，当 Java 层调用 native 函数时，直接就能找到 JNI 层的对应的函数指针了
  • JNINativeMethod 这个结构体里之所以需要一个函数签名信息，是因为 Java 支持函数重载
  • 只有把参数返回值都确定了，才能找到对应的到底是哪个 Java 层函数

动态注册小结

  • 动态注册是 C/C++ 世界告诉某个 Java 虚拟机：我的这个函数，是给这个 Java 类用的，它对应该类的这个 native 方法。
  • 注意： C/C++ 是把这种对应关系告诉了虚拟机，而不是告诉某个 Java 类，即不是告诉了 Java 程序员。跟静态注册一样，只有虚拟机需要关心 java 层的方法和 jni 层的函数之间的对应关系，而不是 Java 程序员需要关心。
  • 注意：C/C++ 里的一个函数，对应的是 Java 里的某个类的某个方法。Java里必须有类。
  • 因为动态注册的过程，是 C/C++ 跟虚拟机对话的过程，所以 C/C++ 必须先拿到那个虚拟机才能进行注册。在 C/C++ 世界，Java 虚拟机的代表就是这两个结构体变量：JavaVM, JNIEnv。

Android 动态注册的一般流程

  • 先把实现了 Java 层 native 函数的那些函数的指针都封装到 JNINativeMethod 数组里
static JNINativeMethod gMethods[]={
    {
        "processFile",
        "(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V",
        (void*)android_meida_MediaScanner_processFile
    },

    {
        "native_init",
        "()V",
        (vodi*)android_meida_MediaScanner_native_init
    }
};
  • 通过方便函数 AndroidRuntime::registerNativeMethods(env,"android/media/MediaScanner",gMethods,ELEN(gMethods)) 来注册
  • 而不是直接使用 (*env)->RegisterNatives(env,clazz,gMethods,numMethods)
  • 因为方便函数的第二个参数直接传字符串就可以了，不用先通过字符串生成一个 jclass 类型再传

在JNI层操作Java层的东西

调用Java层的方法

  1. 通过 jclass clazz = env->FindClass("含有路径的类名"); 找到类
  2. 通过 jmethodID mid = env->GetMethodID(clazz,"方法名","方法签名信息");找到Java层方法的ID
    • 注意 jmethodID 是一个专门记录 Java 层方法的类型
    • 类似的还有一个 jfieldID
  3. 通过 env->CallxxxMethod(jobj,mid,param1,param2...); 调用 Java 层的方法
    • CallxxxMethod 中的 xxx 是 Java 方法的返回值类型，比如 CallVoidMethod，CallIntMethod
    • 第一个参数是指调用哪个对象的方法，就是 Java 中.前面的那个对象
    • 第二个参数 Java 中的 MethodID
    • 后面的参数就是 Java 方法的参数了，其类型都要是 java 中能处理的类型，比如 jstring，jint，jobject

get和set Java层的field

  1. 通过 jclass clazz = env->FindClass("含有路径的类名"); 找到类
  2. 通过 jfieldID fid = env->GetFieldID(clazz,"成员名","成员类型标示");找到Java层成员变量的ID
  3. 通过 GetxxxField(env,obj,fid); / SetxxxField(env,obj,fid,value); 来get/set相应的成员变量

从无到有: The Invocation API

  • 以上方法都是 Java 主动调用了 native 代码之后，native 代码拿着 JNIEnv 去操作 Java 层的东西
  • 如果现在连 JVM 都没有，C/C++ 世界能不能使用 Java 世界的代码呢？
  • 就像 JAVA 可以通过 loadLibrary 把 C 库加载到内存，然后使用其中的方法一样。C/C++C 也可以先启动一个 JVM，然后使用 Java 的方法。
  • 这要用到 The Invocation API。

hello world

  • 目的： 一个 C/C++ 写的可执行程序，在代码里使用已经编译好的 class 文件里的功能。
  • 下面的例子来自JNI官方文档第5章，本文介绍具体怎么把这个例子运行起来。

1. JAVA Code

public class JavaApp{
    public static void javaMethod(){
        System.out.println("I have done a lot of things by Java!");
    }
}

2. 编译 java：

  • javac JavaApp.java 直接生成 JavaApp.class 没什么好说的。

3. CPP Code

#include <jni.h>       
int main()
{
    JavaVM *jvm;       /* denotes a Java VM */
    JNIEnv *env;       /* pointer to native method interface */
    JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
    vm_args.version = JNI_VERSION_1_6;
    vm_args.ignoreUnrecognized = false;
    JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
    jclass cls = env->FindClass("JavaApp");
    jmethodID mid = env->GetStaticMethodID(cls, "javaMethod", "()V");
    env->CallStaticVoidMethod(cls, mid);
    jvm->DestroyJavaVM();
}

4. 编译CPP

  • 加上-I选项，让gcc能找到 jni.h 和 jni_md.h:
    -I/usr/lib/jvm/java-8-openjdk-amd64/include -I/usr/lib/jvm/java-8-openjdk-amd64/include/linux
  • 加上连接器选项，让ld能找到 libjvm.so:
    -L/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64/server CppApp.cpp -ljvm
    注意： gcc 在做链接时会严格的按照从左到右的顺序，如果 -lxxx 这个库的左边并没有任何东西需要它，那么这个 -lxxx 会被忽略。 因为我们 CppApp.cpp 编译出来的 .o 是需要 libjvm.so 的，所以我们的 -ljvm 一定要出现在 CppApp.cpp 的右边
    参考： http://stackoverflow.com/questions/16860021/undefined-reference-to-jni-createjavavm-linux
  • 最后，完整的编译命令：
gcc -I/usr/lib/jvm/java-8-openjdk-amd64/include -I/usr/lib/jvm/java-8-openjdk-amd64/include/linux -L/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64/server  -o app CppApp.cpp  -ljvm

5. 运行

  • 直接运行 app 会报错链接不上 libjvm.so 这个库。
  • 因为安装完 openJDK8，操作系统并不能找到 libjvm.so。 可以运行 sudo ldconfig -v | grep jvm 验证一下，果然啥也没有。
  • 我们需要自己配置一下，利用 ldconfig 工具。
  • 具体做法是： 在目录 /etc/ld.so.conf.d/ 里添加一个文件： openJDK.conf，这个文件里写上：/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/amd64/server 。 这就是 libjvm.so 所在的目录。 然后运行一下 ldconfig 即可。因为 ldconfig 运行的时候，会去加载目录 /etc/ld.so.conf.d/ 里的所有 .conf 文件。
  • 搞定后直接运行 ./app，会打印出 Java 层的输出，大功告成。

总结

  • 至此，我们已经成功运行了该例子，现在来总结一下Native程序到底是怎么调到java的功能的。
  • 想使用 java code 实现的功能，首先我们得搞一个 JVM 出来，这就是：JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
  • 这个函数是在 libjvm.so 里实现的，此函数是 JNI 标准的一部分，所以随JDK发布。
  • 这个函数能创建一个 JVM 对象，该对象肯定也是活在我们的 Native 进程里的。
  • 这个函数中创建 JVM 的同时，把 JNIEnv 也返回给我们了，即第二个参数。
  • 我们拿着 JNIEnv 就可以随便搞了，像获取 Java 类，获取 methodID，调用 java method 的什么的，都不是新鲜事了。

其他零星

jstring 要手动释放

  • JNI层的jstring要手动释放，这和jstring内部实现有关
  • 用 char *cString = env->GetStringUTFChars(jstring javaString, NULL) 能从jstring类型得到C语言的字符串（char*）
  • 用 jstring javaString = env->NewStringUTF(const char* cString) 能从C语言的字符串得到jstring的类型
  • 以上两种方法调用之后，都要调用 env->ReleaseStringUTFChars(jstring javaString, char* cString)来释放
  • 否则会导致JVM内存泄露

JNI类型签名

  • Java 类型对应到 C/C++ 里都有个对应的类型标示。 比如 Java 的 long，在C/C++里用 “J” 做类型标示。

  • 函数签名信息的格式是：

    (参数1类型标示参数2类型标示...参数n类型标示)返回值类型标示

  • 可以用 javap 工具生成函数签名信息

logcat

  • jni c 语言层往 logcat 里写 log

要点：
1. #include <android/log.h>
2. Android.mk 里：LOCAL_LDLIBS := -llog
3. __android_log_print(ANDROID_LOG_DEBUG, "YourTag", "Your log here %s", a_c_string_var);
4. 上述函数能把log写入logcat，第一个参数是log级别，第二个是Tag，第三个是log的内容。并且第三个参数可以按照print()的方式进行格式化字符串。

参考文档

Android JNI 进阶(含完整 Demo)，flutter蓝牙
m0_64383081的博客
12-16 2544
// jsize GetArrayLength(jarray array) jsize j_size = env->GetArrayLength(arg5); for (int i = 0; i < j_size; i++) { //jobject GetObjectArrayElement(jobjectArray array, jsize index) jstring j_string2 = static_cast(env->GetObjectArrayElement(arg5, i)
Android深入理解JNI（一）JNI原理与静态、动态注册
热门推荐
Android进阶三部曲 - 刘望舒
06-19 2万+
JNI不仅仅在NDK开发中应用，它更是Android系统中Java与Native交互的桥梁，不理解JNI的话，你就只能停留在Java Framework层。这一个系列我们来一起深入学习JNI。
Jni解决了哪些问题？
lostsky的专栏
03-29 465
Jni解决了哪些问题？ Jni原理     JNI是Java Native Interface（Java本地接口）的缩写。JNI作为java和操作系统间的一个直接接口，可以通过JNI使得java直接调用操作系统的资源。目前JNI只能通过c/C++实现，因为jni只是对操作系统资源调用的一个桥接过程。所以理论上在windows下只要是dll文件均可以被调用。java代码编译之后是运行在一个jvm...
JNI进阶篇一
文淑的博客
05-27 3276
前言不知不觉毕业快 2 年了，经历过了太多的事，许多都发生了改变，唯有爱你的心不变，始终坚持，不知未来何如 …JNI由于项目当中需要与底层（C&C++）交互，所以和你们一起来学习 JNI 的相关知识。直接开撸 …有关 NDK 的开发环境搭建，强力推荐以下链接参考： Android NDK 开发（五）AndroidStudio 2.2 NDK的开发环境搭建JNI案列获取字符串Java 层原型方法：
Android自助餐之Jni（五）进阶
CodeMan
05-23 1888
Android自助餐之Jni（五）进阶Android自助餐之Jni五进阶 C2C待完善 函数声明 方法调用 使用androidLog 模块化 类型转换 操作bitmap 其他 C2C++（待完善）函数声明 Java类:package.name.ClassName.methodName();Java方法:public native String methodName(String value) C:J
Java 之JNI进阶篇（四）
编程之路的专栏
10-06 718
文章目录JNI 本地对象的引用类型局部引用全局引用普通全局引用弱全局引用JNI 异常处理动态注册本地方法JNI 中的线程同步线程的注意事项 JNI 本地对象的引用类型 JNI将本地代码使用的对象引用分为两类：局部引用 和全局引用。 局部引用在本地方法调用期间有效，并在方法返回后自动释放。全局引用在显式释放之前一直保持有效 局部引用 Java对象会作为局部引用传递给本地方法，JNI函数返回的所有...
JNI原理学习，美团Android面试题
03-17 1295
1.3 Native方法注册 Native方法注册分为两种： 静态注册 多用于NDK开发 动态注册 多用于Framework层开发 下面我们用实际的例子对两种注册做区分及了解。 1.静态注册 我们在Android Studio一个项目中 右键本项目->new->module->Java Library LibraryName = media Java class name = MediaRecorder.java，创建成功后，打开MediaRecorder.class，并学着Me
深入理解Android：多线程与JNI原理解析
本资料《android技术进阶10.pdf》旨在帮助Android新手掌握系统底层原理，从而晋升为高手。以下是对这两个主题的详细解释： 1. **多线程** - **线程安全**：在多线程环境中，当多个线程同时访问共享数据时，可能会...
JNI实战指南：JAVA与C/C++互调及进阶教程
该手册主要关注JNI的实践开发，而非深入原理。 在手册的第一部分，通过一个JAVAC/CPP互相调用的实例，展示了如何实现JAVA调用C/CPP。首先，创建了一个系统已有的DLL文件，这是CPP提供的SDK接口。然后，通过JNI来...
Android高级进阶--免解压密码
01-03
《Android高级进阶--免解压密码》是一本专为Android开发者设计的进阶指南，旨在帮助读者深入理解Android系统的内部工作原理，并掌握无需解压密码的文件处理技术。本书内容丰富，涵盖了Android开发中的诸多关键知识点...
JNI之Hello-JNI进阶
11-16
1. linux下jni环境搭建 参考：http://blog.youkuaiyun.com/zhouyuanjing/article/details/7553706 2. 编写HelloJni工程，在主Activity（本例：HelloJni.java）里声明native函数： 如下： public native String stringFromJNI(); public native double add(double a, double b); public native double sub(double a, double b); public native double multi(double a, double b); public native double div(double a, double b); static { System.loadLibrary("hello-jni"); } 3. 在根目录下创建 jni 目录(mkdir jni). 4. 利用命令生成相应的头文件，在根目录下执行：javah -classpath bin/classes -d jni com.xxx.hello.HelloJni ————————————— ——————— ^ ^ 包名 类名 5. 编写相应的.c文件（hello-jni.c） #include<string.h> #include<jni.h> JNIEXPORT jstring JNICALL Java_com_xxx_hello_HelloJni_stringFromJNI(JNIEnv *env, jobject obj) { return(*env)->NewStringUTF(env, "Hello World from JNI !"); } JNIEXPORT jdouble JNICALL Java_com_xxx_hello_HelloJni_add(JNIEnv *env, jobject obj, jdouble a, jdouble b) { return a + b; } JNIEXPORT jdouble JNICALL Java_com_xxx_hello_HelloJni_sub(JNIEnv *env, jobject obj, jdouble a, jdouble b) { return a - b; } JNIEXPORT jdouble JNICALL Java_com_xxx_hello_HelloJni_multi(JNIEnv *env, jobject obj, jdouble a, jdouble b) { return a * b; } JNIEXPORT jdouble JNICALL Java_com_xxx_hello_HelloJni_div(JNIEnv *env, jobject obj, jdouble a, jdouble b) { return a / b; } 6. jni目录下编写Android.mk文件 LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := hello-jni LOCAL_SRC_FILES := hello-jni.c include $(BUILD_SHARED_LIBRARY) 在根目录下运行：ndk-build xxx@xion-driver:~/android_env/eclipse/Workspace/HelloJni$ndk-build Install : libhello-jni.so => libs/armeabi/libhello-jni.so 可以看到已经正确的生成了libhello-jni.so共享库了。 7. Eclipse运行该工程即可。 ~~完~~
Android调用JNI的进阶实例1（摄像头预览数据转码RGB播放）
12-07
Android调用JNI的进阶实例1（摄像头预览数据转码RGB播放） 请参考我的博客http://blog.youkuaiyun.com/ericfantastic/article/details/50206557
Jni原理
汪子涵的博客
05-27 311
Jni内存泄漏：全局引用造成的内存泄漏、Native方法中过度分配局部引用（循环调用newStringUTF，会造成Jni局部引用表溢出，因为局部引用表存放着局部引用和Java对象的对应关系，局部引用和局部变量不同） Jni引用类型： 局部引用是JVM负责的引用类型，其被JVM分配管理，并占用JVM的资源，局部引用在Native方法返回后被自动回收，局部引用只在创建它们的线程中有效，不能跨线程...
JNI 原理
dev晴天的博客
03-22 543
知识点 先放张图，emmmm 待续！！！！
JNI原理
一个码农的博客
03-15 1300
JNI方法注册方式 Android系统在启动启动过程中，先启动Kernel创建init进程，紧接着由init进程fork第一个横穿Java和C/C++的进程，即Zygote进程。Zygote启动过程中会AndroidRuntime.cpp中的startVm创建虚拟机，VM创建完成后，紧接着调用startReg完成虚拟机中的JNI方法注册。 1.android系统启动时候已经预注册好 这种多出现在android自己系统代码里提供的注册方法 startReg AndroidRuntime.cpp int And
jni原理
Kelvin的专栏
10-31 459
概念 jni是Java Native Interface的缩写，是链接Java层和Native层的桥梁，提供了Java层和Native层（C/C++）相互调用的能力。 Java世界的代码要怎么使用Native世界的代码呢，这就需要一个桥梁来将它们连接在一起，而JNI就是这个桥梁。 以Android中的MediaRecorder为例： java层的代码： public class MediaRec...
Android JNI 进阶(含完整 Demo)
高级开发者进阶ing... QaQ
04-28 1251
Android JNI 进阶native 接收 java 传递基本数据和数组引用类型 静态/动态 方法调用引用类型进阶构造函数调用全局引用 上一章:Android JNI 入门(含完整Demo) native 接收 java 传递基本数据和数组 定义 native: //基本类型调用 public native void nativeBasicTypes(int arg0, double arg2, boolean arg3, String arg4, String[] arg5, int[] arg6)
JNI编程原理
05-30 4272
在手机上实现目标检测与分类，跑一个深度学习模型，或者把复杂算法的实现放在native层，java层只负责简单逻辑。这都涉及到jni的知识，本文将最常用的jni知识做了个整理，作为自己的总结，同时也做个分享。
零基础 JNI 入门 + 进阶
data_backups的博客
09-01 1758
JNI入门 简介 文档：Java Native Interface Specification http://docs.oracle.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html   什么是JNI？ Java Native Interface (JNI).    The JNI is a native progr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值