Thread.start() ，它是怎麼讓線程啓動的呢？

時間  2020-11-27
標籤 html java linux git github 面試 編程 windows 微信 app 欄目 HTML 简体版
原文   原文鏈接


做者：小傅哥
博客：https://bugstack.cn
Github：https://github.com/fuzhengwei/CodeGuide/wikihtml

沉澱、分享、成長，讓本身和他人都能有所收穫！😄

1、前言

有句話：正由於你優秀，因此難以卓越！java

剛開始聽這句話還在上學，既不卓越、也不優秀，甚至可能還有點笨！但忽然從某次爬到班級的前幾名後，開始喜歡上了這種感受，原來前面的風景是如此燦爛😜！linux

優秀和卓越差的不是一個等級，當你感受本身優秀後，還能保持空瓶的心態開始，才能逐步的像卓越邁進，並漫漫長！git

是不小時候更容易學會更多的知識，但越大越笨了！人可能很容易被本身的年紀大了，當成長者。卻不多能保持一個低姿態謙卑的心態，不斷的學習。因此最後，放不下本身，也拾不起能力。github

喜歡一句話，藍是天的顏色、紅是火的象徵，我不學大海抄襲天的藍、也不學晚霞模擬火的紅。我就是我，生命是個人、命運是個人。健身也是你的、學習也是你的，只要你有一個好心態，天然會走到前面卓越那裏！面試

2、面試題

謝飛機，小記！ 碼德，年輕人寫代碼好猖狂，不遵照規範還噴我，你要耗子尾汁！謝飛機罵罵咧咧的下班後，找面試官聊心得。編程

謝飛機：我感受每天就像活在糞堆，代碼都是亂糟糟，我有心無力！windows

面試官：怎麼，想跳槽了？微信

謝飛機：想去寫代碼有規範的公司，想提高！app

面試官：嗯！確實，有些大公司的代碼質量要好一些。可是你也要自身能力強的。

謝飛機：是的，我一直在努力學習！準備跑路！

面試官：那我順便考你個題，看看你進大廠的概率大不。嗯... Java 線程如何啓動的？

謝飛機：如何啓動的？start 啓動的！

面試官：還有嗎？

謝飛機：嗯...，沒了！

面試官：嗯，可能會與不會這一個題並不會讓你代碼有多牛、有多好，可是你的技術棧深度和廣度，決定你的編程職業生涯是否有一條康莊大道。仍是要多努力！

3、線程啓動分析

new Thread(() -> {
    // todo
}).start();

咳咳，Java 的線程建立和啓動很是簡單，但若是問一個線程是怎麼啓動起來的每每並不清楚，甚至不知道爲何啓動時是調用start()，而不是調用run()方法呢？

那麼，爲了讓你們有一個更直觀的認知，咱們先站在上帝視角。把這段 Java 的線程代碼，到 JDK 方法使用，以及 JVM 的相應處理過程，展現給你們，以方便咱們後續逐步分析。

圖 19-1 線程啓動分析

以上，就是一個線程啓動的總體過程分析，會涉及到以下知識點：

  • 線程的啓動會涉及到本地方法（JNI）的調用，也就是那部分 C++ 編寫的代碼。
  • JVM 的實現中會有不一樣操做系統對線程的統一處理，好比：Win、Linux、Unix。
  • 線程的啓動會涉及到線程的生命週期狀態（RUNNABLE），以及喚醒操做，因此最終會有回調操做。也就是調用咱們的 run() 方法

接下來，咱們就開始逐步分析每一步源碼的執行內容，從而瞭解線程啓動過程。

4、線程啓動過程

1. Thread start UML 圖

圖 19-2 Thread start UML 圖

如圖 19-2 是線程的啓動過程時序圖，總體的鏈路較長，會涉及到 JVM 的操做。核心源碼以下：

  1. Thread.c：https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/java.base/share/native/libjava/Thread.c
  2. jvm.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cpp
  3. thread.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp
  4. os.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hpp
  5. os_linux.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp
  6. os_windows.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/windows/vm/os_windows.cpp
  7. vmSymbols.hpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/classfile/vmSymbols.hpp

2. Java 層面 Thread 啓動

2.1 start() 方法

new Thread(() -> {
    // todo
}).start();

// JDK 源碼
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()，在它的方法英文註釋中已經把核心內容描述出來。Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread. 這段話的意思是：由 JVM 調用此線程的 run 方法，使線程開始執行。其實這就是一個 JVM 的回調過程，下文源碼分析中會講到
  • 另外 start() 是一個 synchronized 方法，但爲了不屢次調用，在方法中會由線程狀態判斷。threadStatus != 0。
  • group.add(this)，是把當前線程加入到線程組，ThreadGroup。
  • start0()，是一個本地方法，經過 JNI 方式調用執行。這一步的操做纔是啓動線程的核心步驟。

2.2 start0() 本地方法

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

// 註冊本地方法
public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }
    // ...
}
  • start0()，是一個本地方法，用於啓動線程。
  • registerNatives()，這個方法是用於註冊線程執行過程當中須要的一些本地方法，好比：start0、isAlive、yield、sleep、interrupt0等。

registerNatives，本地方法定義在 Thread.c 中，如下是定義的核心源碼：

static JNINativeMethod methods[] = {
    {"start0",           "()V",        (void *)&JVM_StartThread},
    {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},
    {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},
    {"suspend0",         "()V",        (void *)&JVM_SuspendThread},
    {"resume0",          "()V",        (void *)&JVM_ResumeThread},
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    {"yield",            "()V",        (void *)&JVM_Yield},
    {"sleep",            "(J)V",       (void *)&JVM_Sleep},
    {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},
    {"interrupt0",       "()V",        (void *)&JVM_Interrupt},
    {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},
    {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},
    {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
    {"setNativeName",    "(" STR ")V", (void *)&JVM_SetNativeThreadName},
};

3. JVM 建立線程

3.1 JVM_StartThread

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cpp

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  
  // 建立線程
  native_thread = new JavaThread(&thread_entry, sz);
  // 啓動線程
  Thread::start(native_thread);

JVM_END
  • 這部分代碼比較多，但核心內容主要是建立線程和啓動線程，另外 &thread_entry 也是一個方法，以下：

thread_entry，線程入口

static void thread_entry(JavaThread* thread, TRAPS) {
  HandleMark hm(THREAD);
  Handle obj(THREAD, thread->threadObj());
  JavaValue result(T_VOID);
  JavaCalls::call_virtual(&result,
                          obj,
                          KlassHandle(THREAD, SystemDictionary::Thread_klass()),
                          vmSymbols::run_method_name(),
                          vmSymbols::void_method_signature(),
                          THREAD);
}

重點，在建立線程引入這個線程入口的方法時，thread_entry 中包括了 Java 的回調函數 JavaCalls::call_virtual。這個回調函數會由 JVM 調用。

vmSymbols::run_method_name()，就是那個被回調的方法，源碼以下：

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/classfile/vmSymbols.hpp

#define VM_SYMBOLS_DO(template, do_alias)
template(run_method_name, "run")
  • 這個 run 就是咱們的 Java 程序中會被調用的 run 方法。接下來咱們繼續按照代碼執行鏈路，尋找到這個被回調的方法在何時調用的。

3.2 JavaThread

native_thread = new JavaThread(&thread_entry, sz);

接下來，咱們繼續看 JavaThread 的源碼執行內容。

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
  Thread()
#if INCLUDE_ALL_GCS
  , _satb_mark_queue(&_satb_mark_queue_set),
  _dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{
  if (TraceThreadEvents) {
    tty->print_cr("creating thread %p", this);
  }
  initialize();
  _jni_attach_state = _not_attaching_via_jni;
  set_entry_point(entry_point);
  // Create the native thread itself.
  // %note runtime_23
  os::ThreadType thr_type = os::java_thread;
  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :os::java_thread;
  os::create_thread(this, thr_type, stack_sz);
}
  • ThreadFunction entry_point，就是咱們上面的 thread_entry 方法。
  • size_t stack_sz，表示進程中已有的線程個數。
  • 這兩個參數，都會傳遞給 os::create_thread 方法，用於建立線程使用。

3.3 os::create_thread

源碼：

衆所周知，JVM 是個啥！，因此它的 OS 服務實現，Liunx 還有 Windows 等，都會實現線程的建立邏輯。這有點像適配器模式

os_linux -> os::create_thread

bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
  assert(thread->osthread() == NULL, "caller responsible");

  // Allocate the OSThread object
  OSThread* osthread = new OSThread(NULL, NULL);
  // Initial state is ALLOCATED but not INITIALIZED
  osthread->set_state(ALLOCATED);
  
  pthread_t tid;
  int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

  return true;
}
  • osthread->set_state(ALLOCATED)，初始化已分配的狀態，但此時並無初始化。
  • pthread_create，是類Unix操做系統（Unix、Linux、Mac OS X等）的建立線程的函數。
  • java_start，重點關注類，是實際建立線程的方法。

3.4 java_start

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp

static void *java_start(Thread *thread) {

  // 線程ID
  int pid = os::current_process_id();

  // 設置線程
  ThreadLocalStorage::set_thread(thread);

  // 設置線程狀態：INITIALIZED 初始化完成
  osthread->set_state(INITIALIZED);
  
  // 喚醒全部線程
  sync->notify_all();

 // 循環，初始化狀態，則一致等待 wait
 while (osthread->get_state() == INITIALIZED) {
    sync->wait(Mutex::_no_safepoint_check_flag);
 }

  // 等待喚醒後，執行 run 方法
  thread->run();

  return 0;
}
  • JVM 設置線程狀態，INITIALIZED 初始化完成。
  • sync->notify_all()，喚醒全部線程。
  • osthread->get_state() == INITIALIZED，while 循環等待
  • thread->run()，是等待線程喚醒後，也就是狀態變動後，才能執行到。這在咱們的線程執行UML圖中，也有所體現

4. JVM 啓動線程

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  
  // 建立線程
  native_thread = new JavaThread(&thread_entry, sz);
  // 啓動線程
  Thread::start(native_thread);

JVM_END
  • JVM_StartThread 中有兩步，建立（new JavaThread）、啓動（Thread::start）。建立的過程聊完了，接下來咱們聊啓動。

4.1 Thread::start

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void Thread::start(Thread* thread) {
  trace("start", thread);

  if (!DisableStartThread) {
    if (thread->is_Java_thread()) {
      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    // 不一樣的 OS 會有不一樣的啓動代碼邏輯
    os::start_thread(thread);
  }
}
  • 若是沒有禁用線程 DisableStartThread 而且是 Java 線程 thread->is_Java_thread()，那麼設置線程狀態爲 RUNNABLE。
  • os::start_thread(thread)，調用線程啓動方法。不一樣的 OS 會有不一樣的啓動代碼邏輯

4.2 os::start_thread(thread)

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hpp

void os::start_thread(Thread* thread) {
  // guard suspend/resume
  MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag);
  OSThread* osthread = thread->osthread();
  osthread->set_state(RUNNABLE);
  pd_start_thread(thread);
}
  • osthread->set_state(RUNNABLE)，設置線程狀態 RUNNABLE
  • pd_start_thread(thread)，啓動線程，這個就由各個 OS 實現類，實現各自系統的啓動方法了。好比，windows系統和Linux系統的代碼是徹底不一樣的。

4.3 pd_start_thread(thread)

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp

void os::pd_start_thread(Thread* thread) {
  OSThread * osthread = thread->osthread();
  assert(osthread->get_state() != INITIALIZED, "just checking");
  Monitor* sync_with_child = osthread->startThread_lock();
  MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
  sync_with_child->notify();
}
  • 這部分代碼 notify() 最關鍵，它能夠喚醒線程。
  • 線程喚醒後，3.4 中的 thread->run(); 就能夠繼續執行了。

5. JVM 線程回調

5.1 thread->run()[JavaThread::run()]

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

// The first routine called by a new Java thread
void JavaThread::run() {
  // ... 初始化線程操做
  
  thread_main_inner();
}
  • os_linux.cpp 類中的 java_start 裏的 thread->run()，最終調用的就是 thread.cpp 的 JavaThread::run() 方法。
  • 這部分還須要繼續往下看，thread_main_inner(); 方法。

5.2 thread_main_inner

源碼：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::thread_main_inner() {

  if (!this->has_pending_exception() &&
      !java_lang_Thread::is_stillborn(this->threadObj())) {
    {
      ResourceMark rm(this);
      this->set_native_thread_name(this->get_thread_name());
    }
    HandleMark hm(this);
    this->entry_point()(this, this);
  }

  DTRACE_THREAD_PROBE(stop, this);

  this->exit(false);
  delete this;
}
  • 這裏有你熟悉的設置的線程名稱，this->set_native_thread_name(this->get_thread_name())。
  • this->entry_point()，實際調用的就是 3.1 中的 thread_entry 方法。
  • thread_entry，方法最終會調用到 JavaCalls::call_virtual 裏的vmSymbols::run_method_name()。也就是 run() 方法，至此線程啓動完成。終於串回來了！

5、總結

  • 線程的啓動過程涉及到了 JVM 的參與，因此若是沒有認真瞭解過，確實很難從一個本地方法瞭解的如此透徹。
  • 整個源碼分析能夠結合着代碼調用UML時序圖進行學習，基本核心過程包括：Java 建立線程和啓動、調用本地方法 start0()、JVM 中 JVM_StartThread 的建立和啓動、設置線程狀態等待被喚醒、根據不一樣的OS啓動線程並喚醒、最後回調 run() 方法啓動 Java 線程。
  • 有時候可能只是一步很簡單的方法，也會有它的深刻之處，當真的懂了之後，就不用死記硬背。若是須要得到以上高清大圖，能夠添加小傅哥微信(fustack)，備註：Thread大圖

6、系列推薦

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程