教小師妹學多線程，一個有深度的例子！

作者：小傅哥

部落格：https://bugstack.cn

沉澱、分享、成長，讓自己和他人都能有所收獲！😄

一、前言

對于在校學習期間的計算機、軟體工程的學生來說，隻要學到 Java 多線程，就開始犯迷糊了！

剛知道咋打開 IDEA，費勁扒拉的寫個 HelloWorld，就要上手搞多線程絕對是史詩級了解難度。

這東西怎麼跑起來的

、

怎麼還有一個run方法

各種狀态是啥意思

還要休眠睡一會

，納尼？

以我的學習經曆來說，一個知識點是否能快速接受并學習到，往往是看有沒有一個合适的場景和好的例子，來引導讀者學習到這樣的技術，就像；

Git：上廁所不叫上廁所，叫拉分支！
Socket：廁所就是伺服器，坑就是端口！
隊列：上廁所🚽叫入隊列，先進先出！
棧：去廚房🥣叫進棧，後進先出！
架構：三居的格局叫MVC，四居的格局叫DDD！
理論：系統結構設計定的好，有點bug沒問題，能改。這就是茅坑跟坐便的差別。

除了有點味道以外，這回是不記住了，我們程式設計寫代碼的過程和我們日常生活的例子，往往都是這樣可以對應上，有了真實可以觸及的實物，再去了解程式設計就會更加容易，也很難忘記。

二、給小師妹一個臉紅的多線程

一個最開始接觸多線程知識的未來500強工程師，也可能需要翻很多次書、寫很多例子、敲很多代碼，才能大概了解個7788，不是這知識有多難，主要是例子不好，不進腦子。

那麼，接下來我們模拟鹿鼎記·麗春院，清倌喝茶吟詩聊風月日常。當有達官貴人來時，需要配置設定清倌給大老爺。中間會有一些等待、叫醒操作。隻為讓你更好的記住這樣的案例，不要想歪喽。清倌人即是隻賣藝歡場人，喊麥的。

1. wait & notify 等待和叫醒

案例代碼

public class 麗春院 {

    public static void main(String[] args) {
        老鸨 鸨子 = new 老鸨();

        清倌 miss = new 清倌(鸨子);
        客官 guest = new 客官(鸨子);

        Thread t_miss = new Thread(miss);
        Thread t_guest = new Thread(guest);

        t_miss.start();
        t_guest.start();
    }

}

class 清倌 implements Runnable {

    老鸨 鸨子;

    public 清倌(老鸨 鸨子) {
        this.鸨子 = 鸨子;
    }

    @Override
    public void run() {
        int i = 1;
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            if (i == 1) {
                try {
                    鸨子.在崗清倌("蒼田野子", "500 日元");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                try {
                    鸨子.在崗清倌("花田崗子", "800 日元");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = (i + 1) % 2;
        }
    }

}

class 客官 implements Runnable {

    老鸨 鸨子;

    public 客官(老鸨 鸨子) {
        this.鸨子 = 鸨子;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            try {
                鸨子.喝茶吟詩聊風月();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class 老鸨 {

    private String 清倌 = null;
    private String price = null;
    private boolean 工作狀态 = true;

    public synchronized void 在崗清倌(String 清倌, String price) throws InterruptedException {
        if (!工作狀态)
            wait();//等待
        this.清倌 = 清倌;
        this.price = price;
        工作狀态 = false;
        notify();//叫醒
    }

    public synchronized void 喝茶吟詩聊風月() throws InterruptedException {
        if (工作狀态)
            wait();//等待
        System.out.println("聊風月：" + 清倌);
        System.out.println("茶水費：" + price);
        System.out.println("  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + 清倌 + "完事" + "準備 ... ...");
        System.out.println("****************************************");
        工作狀态 = true;
        notify();//叫醒
    }

}

測試結果

聊風月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準備 ... ...
****************************************
聊風月：花田崗子
茶水費：800 日元
                    花田崗子完事準備 ... ...
****************************************
聊風月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準備 ... ...
****************************************

...

小師妹 ，說看完例子就懂了！
首先這樣的例子它貼近于電視劇、影視作品中經常出現的場景。把生活與技術結合後，你會發現原本不好了解的技術點就好了解了！
wait 和 notify/nofityall，是一對方法，有一個等待，就會有一個叫醒，否則程式就夯在那不動了。關于這部分會使用到的 synchronized 在之前小傅哥有深入的源碼分析，講到它是怎麼加鎖在對象頭的，如果你忘記了可以翻翻看《synchronized 解毒，剖析源碼深度分析！》
了解了基礎的例子，接下來在深入學習線程中的各項技術點，就比較容易在頭腦中帶着場景去驗證和學習了。

2. yield

yield 方法讓出CPU，但不一定，一定讓出！。這種可能會用在一些同時啟動的線程中，按照優先級保證重要線程的執行，也可以是其他一些特殊的業務場景（例如這個線程内容很耗時，又不那麼重要，可以放在後面）。

為了驗證這個方法，我們做一個例子：啟動50個線程進行，每個線程都進行1000次的加和計算。其中10個線程會執行讓出CPU操作。那麼，如果讓出CPU那10個線程的計算加和時間都比較長，說明确實在進行讓出操作。

private static volatile Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
static class Y implements Runnable {
    private String name;
    private boolean isYield;
    public Y(String name, boolean isYield) {
        this.name = name;
        this.isYield = isYield;
    }
    @Override
    public void run() {
        long l = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            if (isYield) Thread.yield();
            AtomicInteger atomicInteger = count.get(name);
            if (null == atomicInteger) {
                count.put(name, new AtomicInteger(1));
                continue;
            }
            atomicInteger.addAndGet(1);
            count.put(name, atomicInteger);
        }
        System.out.println("線程編号：" + name + " 執行完成耗時：" + (System.currentTimeMillis() - l) + " (毫秒)" + (isYield ? "讓出CPU----------------------" : "不讓CPU"));
    }
}

public static void main(String[] args) {
    for (int i = 0; i < 50; i++) {
        if (i < 10) {
            new Thread(new Y(String.valueOf(i), true)).start();
            continue;
        }
        new Thread(new Y(String.valueOf(i), false)).start();
    }
}

線程編号：10 執行完成耗時：2 (毫秒)不讓CPU
線程編号：11 執行完成耗時：2 (毫秒)不讓CPU
線程編号：15 執行完成耗時：1 (毫秒)不讓CPU
線程編号：14 執行完成耗時：1 (毫秒)不讓CPU
線程編号：19 執行完成耗時：1 (毫秒)不讓CPU
線程編号：18 執行完成耗時：1 (毫秒)不讓CPU
線程編号：22 執行完成耗時：0 (毫秒)不讓CPU
線程編号：26 執行完成耗時：0 (毫秒)不讓CPU
線程編号：27 執行完成耗時：1 (毫秒)不讓CPU
線程編号：30 執行完成耗時：0 (毫秒)不讓CPU
線程編号：42 執行完成耗時：1 (毫秒)不讓CPU
線程編号：45 執行完成耗時：1 (毫秒)不讓CPU
線程編号：43 執行完成耗時：1 (毫秒)不讓CPU
線程編号：46 執行完成耗時：0 (毫秒)不讓CPU
線程編号：47 執行完成耗時：0 (毫秒)不讓CPU
線程編号：35 執行完成耗時：0 (毫秒)不讓CPU
線程編号：33 執行完成耗時：0 (毫秒)不讓CPU
線程編号：32 執行完成耗時：0 (毫秒)不讓CPU
線程編号：41 執行完成耗時：0 (毫秒)不讓CPU
線程編号：48 執行完成耗時：1 (毫秒)不讓CPU
線程編号：6 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編号：7 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編号：49 執行完成耗時：2 (毫秒)不讓CPU
線程編号：29 執行完成耗時：1 (毫秒)不讓CPU
線程編号：2 執行完成耗時：17 (毫秒)讓出CPU----------------------
線程編号：1 執行完成耗時：11 (毫秒)讓出CPU----------------------
線程編号：4 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編号：8 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編号：5 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編号：9 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編号：0 執行完成耗時：21 (毫秒)讓出CPU----------------------
線程編号：3 執行完成耗時：21 (毫秒)讓出CPU----------------------

從測試結果可以看到，那些讓出 CPU 的，執行完計算已經在10毫秒以上，說明我們的測試是效果的。

3. join

join 是兩個線程的合并嗎？不是的！

join 是讓線程進入 wait ，當線程執行完畢後，會在JVM源碼中找到，它執行完畢後，其實執行notify，也就是

等待

和

叫醒

操作。

源碼：jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
	// Notify waiters on thread object. This has to be done after exit() is called
	// on the thread (if the thread is the last thread in a daemon ThreadGroup the
	// group should have the destroyed bit set before waiters are notified).
	ensure_join(this);
}
static void ensure_join(JavaThread* thread) {
  // 叫醒
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);
}

好的，就是這裡！

lock.notify_all(thread)

，執行到這，就對上了。

Thread thread = new Thread(() -> {
    System.out.println("thread before");
    try {
        Thread.sleep(3000);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("thread after");
});
thread.start();
System.out.println("main begin！");
thread.join();
System.out.println("main end！");

main begin！
thread before
thread after
main end！

Process finished with exit code 0

首先join() 是一個synchronized方法，裡面調用了wait()，這個過程的目的是讓持有這個同步鎖的線程進入等待，那麼誰持有了這個同步鎖呢？答案是主線程，因為主線程調用了threadA.join()方法，相當于在threadA.join()代碼這塊寫了一個同步代碼塊，誰去執行了這段代碼呢，是主線程，是以主線程被wait()了。然後在子線程threadA執行完畢之後，JVM會調用lock.notify_all(thread);喚醒持有threadA這個對象鎖的線程，也就是主線程，會繼續執行。

這部分驗證的主要展現就是加了 thread.join() 後，會影響到輸出結果。如果不加， main end！ 會優先 thread after 提前列印出來。
join() 是一個 synchronized 方法，裡面調用了 wait() 方法，讓持有目前同步鎖的線程進入等待狀态，也就是主線程。當子線程執行完畢後，我們從源碼中可以看到 JVM 調用了 lock.notify_all(thread) 是以喚醒了主線程繼續執行。

三、線程啟動過程

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

咳咳，Java 的線程建立和啟動非常簡單，但如果問

一個線程是怎麼啟動起來的

往往并不清楚，甚至不知道為什麼啟動時是

調用start()

，而不是

調用run()

方法呢？

那麼，為了讓大家有一個更直覺的認知，我們先站在上帝視角。把這段 Java 的線程代碼，到 JDK 方法使用，以及 JVM 的相應處理過程，展示給大家，以友善我們後續逐漸分析。

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

線程的啟動會涉及到本地方法（JNI）的調用，也就是那部分 C++ 編寫的代碼。
JVM 的實作中會有不同作業系統對線程的統一處理，比如：Win、Linux、Unix。
線程的啟動會涉及到線程的生命周期狀态（RUNNABLE），以及喚醒操作，是以最終會有回調操作。也就是調用我們的 run() 方法

接下來，我們就開始逐漸分析每一步源碼的執行内容，進而了解線程啟動過程。

1. Thread start UML 圖

如圖 19-2 是線程的啟動過程時序圖，整體的鍊路較長，會涉及到 JVM 的操作。核心源碼如下：

Thread.c ：https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/java.base/share/native/libjava/Thread.c
jvm.cpp ：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cpp
thread.cpp ：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp
os.cpp ：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hpp
os_linux.cpp ：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp
os_windows.cpp ：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/windows/vm/os_windows.cpp
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},
};

源碼：https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/java.base/share/native/libjava/Thread.c
從定義中可以看到， start0 方法會執行 &JVM_StartThread 方法，最終由 JVM 層面啟動線程。

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

源碼：

os_linux.cpp
os_windows.cpp

衆所周知，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

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)

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()]

// 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

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() 方法，至此線程啟動完成。終于串回來了！

四、Thread 狀态關系

Java 的線程狀态描述在枚舉類

java.lang.Thread.State

中，共包括如下五種狀态：

public enum State {
    NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}

這五種狀态描述了一個線程的生命周期，其實這種狀态碼的定義在我們日常的業務開發中，也經常出現。比如：一個活動的送出、稽核、拒絕、修改、通過、運作、關閉等，是類似的。那麼線程的狀态是通過下圖的方式進行流轉的，如圖 20-1

New ：新建立的一個線程，處于等待狀态。
Runnable ：可運作狀态，并不是已經運作，具體的線程排程各作業系統決定。在 Runnable 中包含了 Ready Running 兩個狀态，當線程調用了 start() 方法後，線程則處于就緒 Ready 狀态，等待作業系統配置設定 CPU 時間片，配置設定後則進入 Running 運作狀态。此外當調用 yield() 方法後，隻是謙讓的允許目前線程讓出CPU，但具體讓不讓不一定，由作業系統決定。如果讓了，那麼目前線程則會處于 Ready 狀态繼續競争CPU，直至執行。
Timed_waiting ：指定時間内讓出CPU資源，此時線程不會被執行，也不會被系統排程，直到等待時間到期後才會被執行。下列方法都可以觸發： Thread.sleep Object.wait Thread.join LockSupport.parkNanos LockSupport.parkUntil
Wating ：可被喚醒的等待狀态，此時線程不會被執行也不會被系統排程。此狀态可以通過 synchronized 獲得鎖，調用 wait 方法進入等待狀态。最後通過 notify、notifyall 喚醒。下列方法都可以觸發： Object.wait Thread.join LockSupport.park
Blocked ：當發生鎖競争狀态下，沒有獲得鎖的線程會處于挂起狀态。例如 synchronized 鎖，先獲得的先執行，沒有獲得的進入阻塞狀态。
Terminated ：這個是終止狀态，從 New 到 Terminated 是不可逆的。一般是程式流程正常結束或者發生了異常。

這裡參考枚舉

State

類的英文注釋了解了每一個狀态碼的含義，接下來我們去嘗試操作線程方法，把這些狀态展現出來。

1. NEW

Thread thread = new Thread(() -> {
});
System.out.println(thread.getState());

// NEW

這個狀态很簡單，就是線程建立還沒有啟動時就是這個狀态。

2. RUNNABLE

Thread thread = new Thread(() -> {
});
// 啟動
thread.start();
System.out.println(thread.getState());

// RUNNABLE

建立的線程啟動後 start() ，就會進入 RUNNABLE 狀态。但此時并不一定在執行，而是說這個線程已經就緒，可以競争 CPU 資源。

3. BLOCKED

Object obj = new Object();
new Thread(() -> {
    synchronized (obj) {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

Thread thread = new Thread(() -> {
    synchronized (obj) {
        try {
            obj.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

thread.start();
while (true) {
    Thread.sleep(1000);
    System.out.println(thread.getState());
}

// BLOCKED
// BLOCKED
// BLOCKED

這段代碼稍微有點長，主要是為了讓兩個線程發生鎖競争。
第一個線程，synchronized 擷取鎖後休眠，不釋放鎖。
第二個線程，synchronized 擷取不到鎖，會被挂起。
那麼最後的輸出結果就會是， BLOCKED

4. WAITING

Object obj = new Object();
Thread thread = new Thread(() -> {
    synchronized (obj) {
        try {
            obj.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

thread.start();

while (true) {
    Thread.sleep(1000);
    System.out.println(thread.getState());
}

// WAITING
// WAITING
// WAITING

隻要在 synchronized 代碼塊或者修飾的方法中，調用 wait 方法，又沒有被 notify 就會進入 WAITING 狀态。
Thread.join 源碼中也是調用的 wait 方法，是以也會讓線程進入等待狀态。

5. TIMED_WAITING

Object obj = new Object();
Thread thread = new Thread(() -> {
    synchronized (obj) {
        try {
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
thread.start();

while (true) {
    Thread.sleep(1000);
    System.out.println(thread.getState());
}

// TIMED_WAITING
// TIMED_WAITING
// TIMED_WAITING

有了上面狀态擷取的對比，這個狀态的擷取就沒什麼難度了。隻要改成 Thread.sleep(100000); 就可以了。

6. TERMINATED

Thread thread = new Thread(() -> {
});
thread.start();

System.out.println(thread.getState());
System.out.println(thread.getState());
System.out.println(thread.getState());

// RUNNABLE
// TERMINATED
// TERMINATED

這個就比較簡單了，隻要一個線程運作完，它的生命周期結束了，就進入了 TERMINATED

五、總結

線程的啟動過程涉及到了 JVM 的參與，是以如果沒有認真了解過，确實很難從一個本地方法了解的如此透徹。
整個源碼分析可以結合着代碼調用UML時序圖進行學習，基本核心過程包括： Java 建立線程和啟動 調用本地方法 start0() JVM 中 JVM_StartThread 的建立和啟動 設定線程狀态等待被喚醒 根據不同的OS啟動線程并喚醒 最後回調 run() 方法啟動 Java 線程
線程狀态和狀态的轉換也是面試中必問的問題，但除了面試是我們自己在開發中，如果真的使用線程，是非常有必要了解線程狀态是如何轉換的。
線程的一些深入學習都是在調用本地方法，也就是需要了解到JVM層面，才能更加深刻的見到c++代碼是如何實作這部分邏輯的。

六、系列推薦

講道理，隻要你是一個愛折騰的程式員，畢業找工作真的不需要再花錢教育訓練！
工作兩年履歷寫成這樣，誰要你呀！
《Java 面經手冊》PDF，全書 417 頁 11.5 萬字，完稿&發版！
synchronized 解毒，剖析源碼深度分析！
BATJTMD，大廠招聘，都招什麼樣Java程式員？

公衆号：bugstack蟲洞棧 | 作者小傅哥多年從事一線網際網路 Java 開發的學習曆程技術彙總，旨在為大家提供一個清晰詳細的學習教程，側重點更傾向編寫Java核心内容。如果能為您提供幫助，請給予支援(關注、點贊、分享)！