Java中的native是如何实现的（JNI）

什么是JNI

JNI是Java Native Interface的缩写，Java本地接口(JNI)提供了将Java与C/C++、汇编等本地代码集成的方案，该规范使得在 Java 虚拟机内运行的 Java 代码可以与其它编程语言互相操做，包括建立本地方法、更新 Java 对象、调用 Java 方法，引用 Java 类，捕捉和抛出异常等，也容许 Java 代码调用 C/C++ 或汇编语言编写的程序和库。使用java与本地已编译的代码交互，一般会丧失平台可移植性。可是，有些状况下这样作是能够接受的，甚至是必须的。例如，使用一些旧的库，与硬件、操做系统进行交互，或者为了提升程序的性能。JNI标准至少要保证本地代码能工做在任何Java 虚拟机环境。

JNI的编程步骤

1. 编写带有native声明的方法的java类
2. 使用javac命令编译所编写的java类
3. 而后使用javah + java类名生成扩展名为h的头文件
4. 使用C/C++实现本地方法
5. 将C/C++编写的文件生成动态链接库

利用JNI简单实现本身的Thread

Java 中的线程

在Java里建立并启动一个线程的代码：

public static void main(String[] args) {
    Thread thread = new Thread(){
        @Override
        public void run() {
            // do something
        }
    }; 
    thread.start();
}

经过查看 Thread 类的源码，能够发现 start() 方法中最核心的就是调用了 start0() 方法，而 start0() 方法又是一个native方法：

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) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

// native 本地方法
private native void start0();

这里就是经过 Java 代码来调用 JVM 本地的 C 代码，C 中调用系统函数建立线程，而且会反过来调用 Thread 中的 run() 方法，这也是为何调用了 start() 方法后会自动执行 run() 方法中的逻辑。

操做系统的线程

了解一下 Linux 操做系统中是如何建立一个线程的，建立线程函数：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);

使用 man 命令能够查看 pthread_create，这个函数是linux系统的函数，能够用C或者C++直接调用，函数有四个参数：

• pthread_t *thread：传出参数，调用以后会传出被建立线程的id
• const pthread_attr_t *attr：线程属性，传NULL便可，保持默认属性
• void (start_routine) (void *)： 线程的启动后的主体函数 至关于java当中的run
• void *arg：主体函数的参数，若是没有能够传NULL

在 Linux 上启动一个线程的代码：

#include <pthread.h> //头文件
#include <stdio.h>
pthread_t pid; //定义一个变量，接受建立线程后的线程id
//定义线程的主体函数
void* thread_entity(void* arg)
{   
    printf("new Thread!");
}

int main()
{
    // 调用操做系统的函数建立线程，注意四个参数
    pthread_create(&pid, NULL, thread_entity, NULL);
    usleep(100);
    printf("main\n");
}

Java定义本地方法

下面咱们就经过 JNI 技术简单实现一个 Thread 类来模拟线程建立和执行过程。

package com.fantasy;

public class Sample {

    static {
        // 装载库，保证JVM在启动的时候就会装载，这里的库指的是C程序生成的动态连接库
        // Linux下是.so文件，Windows下是.dll文件
        System.loadLibrary( "ThreadNative" );
    }

    public static void main(String[] args) {
        new MyThread(() -> System.out.println("Java run method...")).start();
    }
}

class MyThread implements Runnable {
    private Runnable target;

    public MyThread(Runnable target) {
        this.target = target;
    }

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    public synchronized void start() {
        start0();
    }

    private native void start0();
}

编译成class文件：

[root@sdb1 fantasy]# pwd
/root/com/fantasy
[root@sdb1 fantasy]# javac Sample.java
[root@sdb1 fantasy]# ll
total 12
-rw-r--r--. 1 root root  501 Jun  1 22:10 MyThread.class
-rw-r--r--. 1 root root 1176 Jun  1 22:10 Sample.class
-rw-r--r--. 1 root root  692 Jun  1 22:09 Sample.java

生成.h头文件：

[root@sdb1 ~]# pwd
/root
[root@sdb1 ~]# javah com.fantasy.MyThread
[root@sdb1 ~]# ll
total 4
drwxr-xr-x. 3 root root  21 Jun  1 22:07 com
-rw-r--r--. 1 root root 429 Jun  1 22:12 com_fantasy_MyThread.h

注意：native 方法在哪一个类中就使用javah命令生成对应的头文件，运行 javah 命令须要在包路径外面，javah packageName.className。

下面是 com_fantasy_MyThread.h 头文件的内容：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_fantasy_MyThread */

#ifndef _Included_com_fantasy_MyThread
#define _Included_com_fantasy_MyThread
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_fantasy_MyThread
 * Method:    start0
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_fantasy_MyThread_start0
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

其中 Java_com_fantasy_MyThread_start0 方法就是须要在C程序中定义的方法。
在注释中咱们能够看到有一个 Signature，这个是方法的签名，表示方法的参数类型和返回值类型，简单了解一下：

Java类型	Signature	说明
boolean	Z
byte	B
char	C
short	S
int	I
long	L
float	F
double	D
void	V
Object	L+/分隔的完整类名	例如：Ljava/lang/String表示String类型
Array	[签名	例如: [I表示int类型的数组, [Ljava/lang/String表示String类型的数组
Method	(参数签名)返回类型签名	例如: ([I)I表示参数类型为int数组，返回值int类型的方法

C/C++实现本地方法

上一步已经生成了.h头文件，如今咱们来实现里面定义的方法。建立 thread.c 文件，并编写以下代码：

#include <pthread.h>
#include <stdio.h>
#include "com_fantasy_MyThread.h" // 导入刚刚编译的那个.h文件

pthread_t pid;
void* thread_entity(void* arg)
{
    printf("new Thread!\n");
}

// 这个方法定义要参考.h文件中的方法
JNIEXPORT void JNICALL Java_com_fantasy_MyThread_start0
(JNIEnv *env, jobject obj){
    pthread_create(&pid, NULL, thread_entity, NULL);
    sleep(1);
    printf("main thread %lu, create thread %lu\n", pthread_self(), pid);
    
    //经过反射调用java中的方法
    //找class，使用 FindClass 方法，参数就是要调用的函数的类的彻底限定名，可是须要把点换成/
    jclass cls = (*env)->FindClass(env, "com/fantasy/MyThread");
    //获取 run 方法
    jmethodID mid = (*env)->GetMethodID(env, cls, "run", "()V");
    // 调用方法
    (*env)->CallVoidMethod(env, obj, mid);
    printf("success to call run() method!\n");

}

将这个 thread.c 文件编译为一个动态连接库，命名规则为 libxxx.so，xxx要跟Java中 System.loadLibrary( "ThreadNative") 指定的字符串保持一致，也就是 ThreadNative，编译命令以下：

gcc -fPIC -I /opt/jdk1.8.0_161/include/ -I /opt/jdk1.8.0_161/include/linux -shared -o libThreadNative.so thread.c

至此，Java代码与C代码编写与编译完成。

运行Java代码

运行前，还须要将 .so 文件所在路径加入到path中，这样Java才能找到这个库文件，.so 文件的路径为"/root/libThreadNative.so"，因此配置以下：

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/root/

让咱们来运行Java主类来看一下结果吧！

[root@sdb1 ~]# pwd
/root
[root@sdb1 ~]# ll
total 20
drwxr-xr-x. 3 root root   21 Jun  1 22:07 com
-rw-r--r--. 1 root root  429 Jun  1 22:12 com_fantasy_MyThread.h
-rwxr-xr-x. 1 root root 8336 Jun  1 23:32 libThreadNative.so
-rw-r--r--. 1 root root  666 Jun  1 23:32 thread.c
[root@sdb1 ~]# java com.fantasy.Sample
new Thread!
main thread 139986752292608, create thread 139986681366272
Java run method...
success to call run() method!

能够看到输出结果符合咱们的预期。经过模拟Thread，也能够得出如下结论：

• Thread 类调用 start() 方法会经过jvm调用系统底层函数建立线程，而且回调 run() 方法
• java 级别的线程其实就是操做系统级别的线程