前言

在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,而第四个参数argstart_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_pointthread_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

11-07 07:57