JNI-从jvm源码分析Thread.start的调用与Thread.run的回调
2020-11-06 17:23 tera 阅读(2192) 评论(1) 编辑 收藏 举报前言
在java编程中,线程Thread是我们经常使用的类。那么创建一个Thread的本质究竟是什么,本文就此问题作一个探索。
内容主要分为以下几个部分
1.JNI机制的使用
2.Thread创建线程的底层调用分析
3.系统线程的使用
4.Thread中run方法的回调分析
5.实现一个jni的回调
1.JNI机制的基本使用
当我们new出一个Thread的时候,仅仅是创建了一个java层面的线程对象,而只有当Thread的start方法被调用的时候,一个线程才真正开始执行了。所以start方法是我们关注的目标
查看Thread类的start方法
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
Start方法本身并不复杂,其核心是start0(),真正地将线程启动起来。
接着我们查看start0()方法
private native void start0();
可以看到这是一个native方法,这里我们需要先解释一下什么是native方法。
众所周知java是一个跨平台的语言,用java编译的代码可以运行在任何安装了jvm的系统上。然而各个系统的底层实现肯定是有区别的,为了使java可以跨平台,于是jvm提供了叫java native interface(JNI)的机制。当java需要使用到一些系统方法时,由jvm帮我们去调用系统底层,而java本身只需要告知jvm需要做的事情,即调用某个native方法即可。
例如,当我们需要启动一个线程时,无论在哪个平台上,我们调用的都是start0方法,由jvm根据不同的操作系统,去调用相应系统底层方法,帮我们真正地启动一个线程。因此这就像是jvm为我们提供了一个可以操作系统底层方法的接口,即JNI,java本地接口。
在深入查看start0()方法之前,我们先实现一个自己的JNI方法,这样才能更好地理解start0()方法是如何调用到系统层面的native方法。
首先我们先定义一个简单的java类
package cn.tera.jni;
public class JniTest {
public native void jniHello();
public static void main(String[] args) {
JniTest jni = new JniTest();
jni.jniHello();
}
}
在这个类中,我们定义了一个jniHello的native方法,然后在main方法中对其进行调用。
接着我们调用javac命令将其编译成一个class文件,但和平时不同,我们需要加一个-h参数,生成一个头文件
javac -h . JniTest.java
注意-h后面有一个.,意思是生成的头文件,存放在当前目录
这时我们可以看到在当前目录下生成了2个新文件
JniTest.class:JniTest类的字节码
cn_tera_jni_JniTest.h:.h头文件,这个文件是C和C++中所需要用到的,其中定义了方法的参数、返回类型等,但不包含实现,类似java中的接口,而java代码正是通过这个“接口”找到真正需要执行的方法。
我们查看该.h文件,其中就包含了jniHello方法的定义,当然需要注意到的是,这里的方法名和.h文件本身的命名是jni根据我们类的包名和类名确定出来的,不能修改。
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cn_tera_jni_JniTest */
#ifndef _Included_cn_tera_jni_JniTest
#define _Included_cn_tera_jni_JniTest
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: cn_tera_jni_JniTest
* Method: jniHello
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_cn_tera_jni_JniTest_jniHello
(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
既然我们有了.h头文件,那么自然需要.c或者.cpp的定义实际执行内容的文件,即接口的实现。
我们希望该方法简单地输出一个"hello jni",于是定义如下方法,并将其保存在cn_tera_jni_JniTest.c文件中(这里文件名不需要一致,不过为了可维护性,我们应当定义一致)
#include "cn_tera_jni_JniTest.h"
JNIEXPORT void JNICALL Java_cn_tera_jni_JniTest_jniHello(JNIEnv *env, jobject c1){
printf("hello jni\n");
}
在该文件中,引入了之前生成.h文件(类似于java指定了类实现了哪个接口),并且定义了签名完全一致的Java_cn_tera_jni_JniTest_jniHello方法,此时我们已经有了“接口”和“实现”,接着生成动态链接库即可。
Mac系统运行命令:
gcc -dynamiclib -I /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/include cn_tera_jni_JniTest.c -o libJniTest.jnilib
Linux系统运行命令:
gcc -shared -I /usr/lib/jdk1.8.0_241/include cn_tera_jni_JniTest.c -o libJniTest.so
-dynamiclib、-shared:表示我们需要生成一个动态链接库
-I:之前在.h头文件中我们需要引入jni.h,而该文件位与jdk的目录下,这里-I就是include的意思
-o:表示输出的文件
在Mac系统下,链接库的扩展名为jnilib,命名的格式为libXXX.jnilib
在Linux系统下,链接库扩展名为so,命名格式为libXXX.so
其中的XXX是在运行时加载动态库时用到的名字
此时在目录下就会多出一个libJniTest.jnilib或者libJniTest.so的动态链接库。
最后我们回到一开始的java文件中,引入该库即可。修改JniTest.java
package cn.tera.jni;
public class JniTest {
static {
//设置查找路径为当前项目路径
System.setProperty("java.library.path", ".");
//加载动态库的名称
System.loadLibrary("JniTest");
}
public native void jniHello();
public static void main(String[] args) {
JniTest jni = new JniTest();
jni.jniHello();
}
}
重新编译.class文件,记得将其放到./cn/tera/jni目录下(包名是啥,目录就是啥),然后执行即可。
java cn.tera.jni.JniTest
hello jni
此时我们先总结一下JNI的基本使用顺序
1)在.java文件中定义native方法
2)生成相应的.h头文件(即接口)
3)编写相应的.c或.cpp文件(即实现)
4)将接口和实现链接到一起,生成动态链接库
5)在.java中引入该库,即可调用native方法
2.Thread创建线程的底层调用分析
了解了jni的基本使用流程之后,我们回到Thread的start0方法
为了探究start0()方法的原理,自然需要看看jvm在幕后为我们做了什么。
首先我们需要下载jdk和jvm的源码,因为openjdk和oraclejdk差别很小,而openjdk是开源的,所以我们以openjdk的代码为参考,版本是jdk8
下载地址:http://hg.openjdk.java.net/jdk8
因为C和C++的代码对于java程序员来说比较晦涩难懂,所以在下方展示源码的时候我只会贴出我们关心的重点代码,其余的部分就省略了
在jdk源码的目录src/java.base/share/native/libjava目录下能看到Thread.c文件,对应的是jni中的“实现”
#include "jni.h"
#include "jvm.h"
#include "java_lang_Thread.h"
...
static JNINativeMethod methods[] = {
{"start0", "()V", (void *)&JVM_StartThread},
...
};
JNIEXPORT void JNICALL
Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
{
(*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
}
按照之前我们自己定义的jni实现,该文件中应当有一个Java_java_lang_Thread_start0的方法定义,然而其中实际上只有一个Java_java_lang_Thread_registerNatives的方法定义,对应的正是Thread.java中的registerNatives方法:
class Thread implements Runnable {
private static native void registerNatives();
static {
registerNatives();
}
...
}
由此我们可以发现,Thread类在实现jni的时候并非是将每一个native方法都直接定义在自己的头文件中,而是通过一个registerNatives方法动态注册的,而注册所需要的信息都被定义在了methods数组中,包括方法名、方法签名和接口方法,接口方法的定义被统一放到了jvm.h中(#include "jvm.h")。这个时候该jni接口方法的名字就不再受到固定格式限制了。这个机制以后用单独的文章来解释,现在先关心Thread的本质。
接下去我会按照调用链从上至下的顺序列出文件和方法
1)jvm.h,hotspot目录src/share/vm/prims
既然start0方法的接口方法被定义在jvm.h中,那么我们先查看jvm.h,就可以找到JVM_StartThread的定义了:
JNIEXPORT void JNICALL
JVM_StartThread(JNIEnv *env, jobject thread);
2)jvm.cpp,hotspot目录src/share/vm/prims
接着我们查看jvm.cpp,这里能看到JVM_StartThread的具体实现,关键点是通过创建一个JavaThread类创建线程,注意这里JavaThread是C++级别的线程:
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_StartThread");
JavaThread *native_thread = NULL;
bool throw_illegal_thread_state = false;
{
...
/**
* 创建一个C++级别的线程
*/
native_thread = new JavaThread(&thread_entry, sz);
...
}
...
JVM_END
3)thread.cpp,hotspot目录src/share/vm/runtime
查看thread.cpp,可以看到JavaThread的构造函数,其中创建了一个系统线程:
JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
Thread()
{
...
/**
* 创建系统线程
*/
os::create_thread(this, thr_type, stack_sz);
}
4)os_linux.cpp,hotspot目录src/os/linux/vm
我们能在hotspot源码目录的src/os下找到不同系统的方法,我们以linux系统为例。
查看os_linux.cpp,找到create_thread方法:
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t req_stack_size) {
...
pthread_t tid;
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
...
}
这个pthread_create方法就是最终创建系统线程的底层方法
因此java线程start方法的本质其实就是通过jni机制,最终调用系统底层的pthread_create方法,创建了一个系统线程,因此java线程和系统线程是一个一对一的关系
3.系统线程的使用
接着我们来简单使用一下这个创建线程的方法。创建如下的.c文件,在main方法中创建一个线程,并让2个线程不断打印一些文案
#include <pthread.h>
#include <stdio.h>
pthread_t pid;
void* thread_entity(void* arg){
while (1) {
printf("i am thread\n");
}
}
int main(){
pthread_create(&pid,NULL,thread_entity,NULL);
while (1) {
printf("i am main\n");
}
return 1;
}
编译该文件
gcc threaddemo.c -o threaddemo.out
-o:编译后的执行文件为threaddemo.out
运行该out文件后就能看到2个文案在不断重复打印了,也就是成功通过pthread_create方法创建了一个系统级别的线程。
4.Thread中run方法的回调分析
到这里我们的探究并没有结束,在java的Thread类中,我们会传入一个执行我们指定任务的Runnable对象,在Thread的run()方法中调用。当java通过jni调用到pthread_create创建完系统线程后,又要如何回调java中的run方法呢?
前面的探究我们是从java层开始,从上往下找,此时我们要反过来,从下往上找了。
1)pthread_create
先看pthread_create方法本身,它接收4个参数,其中第三个参数start_routine是系统线程创建后需要执行的方法,就像前面我们创建的简单示例中的thread_entity,而第四个参数arg是start_routine方法需要的参数
pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
2)os_linux.cpp
查看create_thread方法中调用pthread_create的代码,可以看到thread_native_entry就是系统线程所执行的方法,而thread则是传递给thread_native_entry的参数:
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
查看thread_native_entry方法,它获取的参数正是一个Thread,并调用其run()方法。注意这个Thread是C++级别的线程,来自于pthread_create方法的第4个参数:
static void *thread_native_entry(Thread *thread) {
...
// call one more level start routine
thread->run();
...
return 0;
}
3)thread.cpp
查看JavaThread::run()方法,其主要的执行内容在thread_main_inner方法中:
void JavaThread::run() {
/**
* 主要的执行内容
*/
thread_main_inner();
}
查看JavaThread::thread_main_inner()方法,其内部通过entry_point执行回调:
void JavaThread::thread_main_inner() {
...
/**
* 调用entry_point,执行外部传入的方法,注意这里的第一个参数是this
* 即JavaThread对象本身,后面会看到该方法的定义
*/
this->entry_point()(this, this);
...
}
查看JavaThread::JavaThread构造函数,可以看到这里的entry_point是从外部传入的
JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
Thread()
{
...
set_entry_point(entry_point);
...
}
4)jvm.cpp
查看JVM_StartThread方法,可以看到传给JavaThread的entry_point是thread_entry
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_StartThread");
JavaThread *native_thread = NULL;
bool throw_illegal_thread_state = false;
{
...
/**
* 传给构造函数的entry_point是thread_entry
*/
native_thread = new JavaThread(&thread_entry, sz);
...
}
...
JVM_END
查看thread_entry,其中调用了JavaCalls::call_virtual去回调java级别的方法,其实看到它的方法签名就能猜到个大概了
static void thread_entry(JavaThread* thread, TRAPS) {
HandleMark hm(THREAD);
/**
* obj正是根据thread对象获取到的,JavaThread在调用时会传入this
*/
Handle obj(THREAD, thread->threadObj());
/**
* 返回结果是void
*/
JavaValue result(T_VOID);
/**
* 回调java级别的方法
*/
JavaCalls::call_virtual(&result,//返回对象
//实例对象
obj,
//类
KlassHandle(THREAD, SystemDictionary::Thread_klass()),
//方法名
vmSymbols::run_method_name(),
//方法签名
vmSymbols::void_method_signature(),
THREAD);
}
5)vmSymbols.hpp,hotspot目录src/share/vm/classfiles
我们查看获取方法名run_method_name和方法签名void_method_signature的部分,可以看到正是获取一个方法名为run,且不获取任何参数,返回值为void的方法:
template(run_method_name, "run")
...
template(void_method_signature, "()V")
于是系统线程就能成功地回调java级别的run方法了!
这里我整理了一下Thread的start0方法的调用上下游关系,方便大家整体把握
Thread.java
-------->jvm.cpp
-------->thread.cpp
-------->os_linux.cpp
-------->pthread_create
5.实现一个jni的回调
最后我们尝试自己实现一个简单的方法回调。
修改一开始的JniTest.java,新增一个回调方法:
package cn.tera.jni;
public class JniTest {
static {
//设置查找路径为当前项目路径
System.setProperty("java.library.path", ".");
//加载动态库的名称
System.loadLibrary("JniTest");
}
public native void jniHello();
//新增一个回调方法
public void callBack(){
System.out.println("this is call back");
}
public static void main(String[] args) {
JniTest jni = new JniTest();
jni.jniHello();
}
}
修改cn_tera_jni_JniTest.c文件,原先只是简单输出一个文案,现在改为回调java方法。可以看到这个流程和java中的反射机制非常相似:
#include "cn_tera_jni_JniTest.h"
JNIEXPORT void JNICALL Java_cn_tera_jni_JniTest_jniHello(JNIEnv *env, jobject c1){
//获取类信息
jclass thisClass = (*env)->GetObjectClass(env, c1);
//根据方法名和签名获取方法的id
jmethodID midCallBack = (*env)->GetMethodID(env, thisClass, "callback", "()V");
//调用方法
(*env)->CallVoidMethod(env, c1, midCallBack);
}
重新生成动态链接库、编译.class文件、运行:
gcc -dynamiclib -I /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/include cn_tera_jni_JniTest.c -o libJniTest.jnilib
javac JniTest.java
java cn.tera.jni.JniTest
成功得到输出结果:
this is call back
当然,对于有参数的、有返回结果的回调等,jni也提供了不同的调用方法,这个就不在本文中展开了,有兴趣的同学可以自己去看下jni.h文件
还要提一点,上面展示的回调只是最基本的使用,而jvm中的官方回调方法,因为涉及到了java的父类继承关系、方法句柄、vtable等等内容,这里也就不展开了,同学们自己研究吧
最后,总结一下本文的内容
1.实现一个jni只需要4个东西,.java文件,.h头文件(相当于接口),.c或.cpp文件(相当于实现),生成的动态链接库。
2.java的Thread是通过jni机制最终调用到了系统底层的pthread_create方法创建线程的。
3.Thread的jni调用链:Thread.java->jvm.cpp->thread.cpp->os_linux.cpp->pthread_create
4.jni也可以回调java方法,从调用到回调完成了一个demo