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);

pthread_create

使用 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  //头文件
#include 
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 
/* 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 
#include 
#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 级别的线程其实就是操作系统级别的线程

你可能感兴趣的:(java,jni,thread)