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

作者：小傅哥
博客：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 的操作。核心源碼如下：

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},
};

• 源碼：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：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

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

四、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程序員？