• 自定义线程实现c++代码回调run方法

    目录

    pthread_create函数介绍

    前面写过一篇文章《Thread类的start()方法创建线程的底层分析》，这次来自定义一个线程，并实现在底层创建内核线程来执行用户代码。

    pthread_create函数介绍

    在这之前，先熟悉下Linux中创建内核线程函数pthread_create的用法。

     pthread_create函数的第一个参数用来接收新创建的线程ID，该参数的类型是pthread_t。如何查看这个类型的定义？在Linux中查找pthread.h

    1. [root]# whereis pthread.h
    2. pthread: /usr/include/pthread.h

     打开pthread.h，发现其引入了pthreadtypes.h

    1. #ifndef _PTHREAD_H
    2. #define _PTHREAD_H      1
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include

    打开即可看到pthread_t的定义

    typedef unsigned long int pthread_t;

    第二个参数用来设置线程属性，可以传空。

    第三个参数是线程运行函数的起始地址。

    最后一个参数是运行函数的参数。

    了解了使用方法，编写如下MyThread.c代码。在main方法中创建新线程，然后在main和java_start方法中循环打印。

    1. #include 
    2. #include 
    3.  
    4. void *java_start(void *arg) {
    5.     while (1)
    6.     {
    7.         usleep(1000000);
    8.         printf("this is java_start method!\n");
    9.     }
    10.     
    11. } 
    12.  
    13. int main() {
    14. 	pthread_t tid;
    15.     pthread_create(&tid, NULL, java_start, NULL);
    16.     while (1)
    17.     {
    18.         usleep(1000000);
    19.         printf("this is main method!\n");
    20.     }
    21.     return 0;
    22. }

    使用如下命令进行编译：

    gcc Mythread.c -o MyThread -pthread

     运行结果如下：

    1. [root@192 yangxianzhu]# ./MyThread 
    2. this is java_start method!
    3. this is main method!
    4. this is java_start method!
    5. this is main method!
    6. this is java_start method!
    7. this is main method!
    8. this is java_start method!
    9. this is main method!
    10. this is main method!
    11. this is java_start method!
    12. this is main method!
    13. this is java_start method!

    至此，就完成了在Linux创建一个新的内核线程。

    自定义线程

    接下来就开始自定义线程。仿照Thread.java，自定义线程MyThread.java代码如下：

    1. package org.example;
    2.  
    3. public class MyThread {
    4.  
    5.     public void start() {
    6.         start0();
    7.     }
    8.  
    9.     private native void start0();
    10.  
    11. }

    其中start0是一个native方法，使用命令javah生成对应的头文件。注意，先进入编译输出目录

     然后执行命令：javah org.example.MyThread，生成的头文件名为org_example_MyThread.h，内容如下：

    1. /* DO NOT EDIT THIS FILE - it is machine generated */
    2. #include 
    3. /* Header for class org_example_MyThread */
    4.  
    5. #ifndef _Included_org_example_MyThread
    6. #define _Included_org_example_MyThread
    7. #ifdef __cplusplus
    8. extern "C" {
    9. #endif
    10. /*
    11.  * Class:     org_example_MyThread
    12.  * Method:    start0
    13.  * Signature: ()V
    14.  */
    15. JNIEXPORT void JNICALL Java_org_example_MyThread_start0
    16.   (JNIEnv *, jobject);
    17.  
    18. #ifdef __cplusplus
    19. }
    20. #endif
    21. #endif

    为了方便后面编译，去除包名。将文件名改成MyThread.h，将里面的方法名JNICALL Java_org_example_MyThread_start0改成JNICALL Java_MyThread_start0。这样，MyThread.java对应的头文件就创建好了。

    接下来修改MyThread.c如下：

    1. #include 
    2. #include 
    3. #include "MyThread.h"
    4.  
    5. void *java_start(void *arg) {
    6.     while (1)
    7.     {
    8.         usleep(1000000);
    9.         printf("this is java_start method!\n");
    10.     }
    11.     
    12. }
    13.  
    14. JNIEXPORT void JNICALL Java_MyThread_start0(JNIEnv *env, jobject obj) {
    15.     pthread_t tid;
    16.     pthread_create(&tid, NULL, java_start, NULL);
    17.     while (1)
    18.     {
    19.         usleep(1000000);
    20.         printf("this is start0 method!\n");
    21.     }
    22. }
    23.  
    24. int main() {
    25.     return 0;
    26. }

    首先引入上面生成的头文件MyThread.h，注意这里使用的是#include "MyThread.h"，表示该头文件与mythread.c在同一目录下。接着实现Java_MyThread_start0方法，将原先放到main方法里的创建线程的逻辑挪过去。

    下面先验证在Java中通过JNI调用mythread.c中的Java_MyThread_start0方法。先将MyThread.c打包成库文件mythread.so，将MyThread.c和MyThread.h拷贝到同一个目录下

    1. [root@192 yangxianzhu]# pwd
    2. /home/yangxianzhu
    3. [root@192 yangxianzhu]# ll
    4. 总用量 8
    5. -rw-r--r--. 1 root root 494 12月  4 15:22 MyThread.c
    6. -rw-r--r--. 1 root root 438 12月  4 14:48 MyThread.h

    由于在MyThread.h中引入了jni.h，该文件位于jdk下的include目录。打包命令如下：

    1. [root@192 yangxianzhu]# gcc -fPIC -I /usr/local/java/jdk1.8.0_341/include -I /usr/local/java/jdk1.8.0_341/include/linux -shared -o MyThread.so MyThread.c
    2. [root@192 yangxianzhu]# ll
    3. 总用量 16
    4. -rw-r--r--. 1 root root  494 12月  4 15:22 MyThread.c
    5. -rw-r--r--. 1 root root  438 12月  4 14:48 MyThread.h
    6. -rwxr-xr-x. 1 root root 8184 12月  4 15:32 MyThread.so

    MyThread.so就是生成的库文件，接着在MyThread.java中通过System.load引入库文件，然后创建MyThread对象并调用start方法进行测试。

    1. package org.example;
    2.  
    3. public class MyThread {
    4.  
    5.     static {
    6.         //加载库文件
    7.         System.load("/home/yangxianzhu/MyThread.so");
    8.     }
    9.  
    10.     public void start() {
    11.         start0();
    12.     }
    13.  
    14.     private native void start0();
    15.  
    16.     public static void main(String[] args) {
    17.         new MyThread().start();
    18.     }
    19. }

    为了方便编译和运行，将MyThread.java中的包路径去除，如下：

    1. public class MyThread {
    2.  
    3.     static {
    4.         //加载库文件
    5.         System.load("/home/yangxianzhu/MyThread.so");
    6.     }
    7.  
    8.     public void start() {
    9.         start0();
    10.     }
    11.  
    12.     private native void start0();
    13.  
    14.     public static void main(String[] args) {
    15.         new MyThread().start();
    16.     }
    17. }

    然后将其拷贝到Linux中的任意目录，此处放到跟库文件同样的/home/yangxianzhu下

    1. [root@192 yangxianzhu]# ll
    2. 总用量 20
    3. -rw-r--r--. 1 root root  494 12月  4 15:22 MyThread.c
    4. -rw-r--r--. 1 root root  438 12月  4 14:48 MyThread.h
    5. -rw-r--r--. 1 root root  311 12月  4 15:37 MyThread.java
    6. -rwxr-xr-x. 1 root root 8184 12月  4 15:32 MyThread.so

    使用javac命令进行编译：

    1. [root@192 yangxianzhu]# javac MyThread.java 
    2. [root@192 yangxianzhu]# ll
    3. 总用量 24
    4. -rw-r--r--. 1 root root  494 12月  4 15:22 MyThread.c
    5. -rw-r--r--. 1 root root  529 12月  4 15:41 MyThread.class
    6. -rw-r--r--. 1 root root  438 12月  4 14:48 MyThread.h
    7. -rw-r--r--. 1 root root  311 12月  4 15:37 MyThread.java
    8. -rwxr-xr-x. 1 root root 8184 12月  4 15:32 MyThread.so

    然后使用java命令运行，结果如下：

    1. [root@192 yangxianzhu]# java MyThread
    2. this is java_start method!
    3. this is start0 method!
    4. this is java_start method!
    5. this is start0 method!
    6. this is java_start method!
    7. this is start0 method!
    8. this is java_start method!
    9. this is start0 method!

    至此就完成了在Java中通过JNI调用MyThread.c中的创建内核线程的方法。

    下面就是如何在MyThread.c中回调MyThread.java中的方法，在MyThread.java中添加run方法

    1. public class MyThread {
    2.  
    3.     static {
    4.         //加载库文件
    5.         System.load("/home/yangxianzhu/MyThread.so");
    6.     }
    7.  
    8.     public void start() {
    9.         start0();
    10.     }
    11.  
    12.     private native void start0();
    13.  
    14.     public void run() {
    15.         System.out.println("this is run method");
    16.     }
    17.  
    18.     public static void main(String[] args) {
    19.         new MyThread().start();
    20.     }
    21. }

    修改MyThread.c内容如下：

    1. #include 
    2. #include 
    3. #include "MyThread.h"
    4.  
    5. JavaVM *javaVM;
    6. int status; //线程状态：0|INITIALIZED、1|RUNNABLE
    7.  
    8. void *java_start(void *arg) {
    9.     JNIEnv *env=NULL;
    10.     (*javaVM)->AttachCurrentThread(javaVM, &env, NULL);
    11.     jclass cls;
    12.     jobject obj;
    13.     jmethodID cid;
    14.     jmethodID rid;
    15.     jint ret=0;
    16.     //通过虚拟机找到Java中的类
    17.     cls=(*env)->FindClass(env, "MyThread");
    18.     if (cls==NULL)
    19.     {
    20.         printf("class is not found\n");
    21.         return;
    22.     }
    23.     //如果找到该类，此时通过无参构造函数new出来
    24.     cid=(*env)->GetMethodID(env, cls, "", "()V");
    25.     if(cid==NULL) {
    26.         printf("constructor is not found\n");
    27.     }
    28.     //通过构造函数实例化
    29.     obj=(*env)->NewObject(env, cls, cid);
    30.     if(obj==NULL) {
    31.         printf("NewObject is error\n");
    32.     }
    33.     //找到run方法
    34.     rid=(*env)->GetMethodID(env, cls, "run", "()V");
    35.     if (rid==NULL)
    36.     {
    37.         printf("run method id not found\n");
    38.     }
    39.     //直到线程状态不为0|INITIALIZED，才会执行下面的run方法
    40.     while (status == 0)
    41.     {
    42.         usleep(1000000);
    43.         printf("thread state is INITIALIZED\n");
    44.     }
    45.     printf("thread state is RUNNABLE\n");
    46.     //开始调用run方法
    47.     (*env)->CallIntMethod(env, obj, rid, NULL);
    48. }
    49.  
    50. JNIEXPORT void JNICALL Java_MyThread_start0(JNIEnv *env, jobject obj) {
    51.     pthread_t tid;
    52.     pthread_create(&tid, NULL, java_start, NULL);
    53.     //休眠5秒后，将线程状态改成1|RUNNABLE
    54.     usleep(5000000);
    55.     status=1;
    56. }
    57.  
    58. //JVM启动的时候调用，对javaVM进行赋值
    59. JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    60.     javaVM=vm;
    61.     return JNI_VERSION_1_8;
    62. }
    63.  
    64. int main() {
    65.     return 0;
    66. }

    重新生成库文件，然后再次编译并运行MyThread，结果如下：

    1. [root@192 yangxianzhu]# java MyThread
    2. thread state is INITIALIZED
    3. thread state is INITIALIZED
    4. thread state is INITIALIZED
    5. thread state is INITIALIZED
    6. thread state is INITIALIZED
    7. thread state is RUNNABLE
    8. this is run method

    可以看出MyThread.java中的run方法被执行了。

    至此就完成了在Java中通过JNI技术调用.C中的代码创建新内核线程，然后在内核线程中回调Java中的方法。

  • 相关阅读:
    Three.JS程序化建模入门
    防火墙实验一
    ORACLE Linux(OEL) - Primavera P6EPPM 安装及分享
    Java从零学起（十二）----HashSet集合
    Spring-boot运行原理(Pom.xml)
    ASP.NET MVC--过滤器
    对于Java循环中的For和For-each，哪个更快
    java IO流 序列化流
    打造顶尖微服务项目！解锁四种持久化工具的酸爽奇迹！
    MSSQL 配置ORACLE ​链接服务器
  • 原文地址：https://blog.csdn.net/u010389391/article/details/128155892