前言
在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