本文主要是介绍Java 线程实现原理，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Linux 操作系统中创建线程的方式

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

#include <pthread.h>
#include <stdio.h>

pthread_t pid;

void* thread_entity(void* arg) {
    printf("run\n");
}

int main() {
    pthread_create(&pid, NULL, thread_entity, NULL);
    // 防止子线程还没启动，就结束了
    usleep(100);
    printf("main\n");
    
    return 0;
}

Thread#start0 实现原理

package java.lang;
public class Thread implements Runnable {
	private static native void registerNatives();
    static {
        registerNatives();
    }
    // JVM 中并没有 Java_java_lang_Thread_start0 方法，因此这个方法是由 registerNatives() 动态注册的
	private native void start0();
}

注册的信息定义在这里src/java.base/share/native/libjava/Thread.c中：

static JNINativeMethod methods[] = {
    {"start0",           "()V",        (void *)&JVM_StartThread}, 
    //......
};

jvm.cpp:

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
    // ... 传给构造函数的 entry_point 是 thread_entry 静态方法
      native_thread = new JavaThread(&thread_entry, sz);
	// ...
}

构造方法在 Thread.cpp:

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : JavaThread() {
  // ...  传进来的 thread_entry 静态方法设置为 entry_point
  set_entry_point(entry_point);
  // ...  启动线程
  os::create_thread(this, thr_type, stack_sz);
}

os_linux.cpp:

// 实现 run() 方法回调
static void *thread_native_entry(Thread *thread) {
 	// ...
    thread->call_run();
    // ...
}

// 启动线程
bool os::create_thread(Thread* thread, ThreadType thr_type,
                       size_t req_stack_size) {
	// ... pthread 创建线程
    int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
    // ...
}

thread.cpp：

void Thread::call_run() {
    // ...  实际类型是 JavaThread，所以调用 JavaThread::run()
    this->run();
    // ...
}

void JavaThread::run() {
    // ...
    thread_main_inner();
}

void JavaThread::thread_main_inner() {
    // ... entry_point 是 thread_entry 静态方法 (构造方法中传进来的)
    this->entry_point()(this, this);
    // ...
}

jvm.cpp:

static void thread_entry(JavaThread* thread, TRAPS) {
  HandleMark hm(THREAD);
  Handle obj(THREAD, thread->threadObj());
  JavaValue result(T_VOID);
    // 回调 Java 方法
  JavaCalls::call_virtual(&result, // 返回对象
                          obj,     // 实例对象
                          vmClasses::Thread_klass(),          // 类
                          vmSymbols::run_method_name(),       // 方法名
                          vmSymbols::void_method_signature(), // 方法签名
                          THREAD);
}

vmSymbols.hpp :

// 回调的方法名写死为 "run"
template(run_method_name, "run")
// 方法签名写死为 无参无返回值
template(void_method_signature, "()V") 

javaCalls.cpp中回调 Java 方法：

void JavaCalls::call_virtual(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
  // ... 不在往下深入了
  JavaCalls::call(result, method, args, CHECK);
}

这篇关于Java 线程实现原理的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！