作者：小傅哥
博客：https://

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

一、前言

對于在校學(xué)習(xí)期間的計算機、軟件工程的學(xué)生來說，只要學(xué)到 Java 多線程，就開始犯迷糊了！

剛知道咋打開 IDEA，費勁扒拉的寫個 HelloWorld，就要上手搞多線程絕對是史詩級理解難度。這東西怎么跑起來的、怎么還有一個run方法、各種狀態(tài)是啥意思、還要休眠睡一會，納尼？

以我的學(xué)習(xí)經(jīng)歷來說，一個知識點是否能快速接受并學(xué)習(xí)到，往往是看有沒有一個合適的場景和好的例子，來引導(dǎo)讀者學(xué)習(xí)到這樣的技術(shù)，就像；

• Git：上廁所不叫上廁所，叫拉分支！
• Socket：廁所就是服務(wù)器，坑就是端口！
• 隊列：上廁所🚽叫入隊列，先進先出！
• 棧：去廚房🥣叫進棧，后進先出！
• 架構(gòu)：三居的格局叫MVC，四居的格局叫DDD！
• 理論：系統(tǒng)結(jié)構(gòu)設(shè)計定的好，有點bug沒問題，能改。這就是茅坑跟坐便的區(qū)別。

除了有點味道以外，這回是不記住了，我們編程寫代碼的過程和我們?nèi)粘Ｉ畹睦?#xff0c;往往都是這樣可以對應(yīng)上，有了真實可以觸及的實物，再去了解編程就會更加容易，也很難忘記。

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

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

那么，接下來我們模擬鹿鼎記·麗春院，清倌喝茶吟詩聊風(fēng)月日常。當(dāng)有達官貴人來時，需要分配清倌給大老爺。中間會有一些等待、叫醒操作。只為讓你更好的記住這樣的案例，不要想歪嘍。清倌人即是只賣藝歡場人，喊麥的。

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 {
                鴇子.喝茶吟詩聊風(fēng)月();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class 老鴇 {

    private String 清倌 = null;
    private String price = null;
    private boolean 工作狀態(tài) = true;

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

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

}

測試結(jié)果

聊風(fēng)月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準(zhǔn)備 ... ...
****************************************
聊風(fēng)月：花田崗子
茶水費：800 日元
                    花田崗子完事準(zhǔn)備 ... ...
****************************************
聊風(fēng)月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準(zhǔn)備 ... ...
****************************************

...

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

2. yield

yield 方法讓出CPU，但不一定，一定讓出！。這種可能會用在一些同時啟動的線程中，按照優(yōu)先級保證重要線程的執(zhí)行，也可以是其他一些特殊的業(yè)務(wù)場景（例如這個線程內(nèi)容很耗時，又不那么重要，可以放在后面）。

為了驗證這個方法，我們做一個例子：啟動50個線程進行，每個線程都進行1000次的加和計算。其中10個線程會執(zhí)行讓出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 + " 執(zhí)行完成耗時：" + (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();
    }
}

測試結(jié)果

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

• 從測試結(jié)果可以看到，那些讓出 CPU 的，執(zhí)行完計算已經(jīng)在10毫秒以上，說明我們的測試是效果的。

3. join

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

join 是讓線程進入 wait ，當(dāng)線程執(zhí)行完畢后，會在JVM源碼中找到，它執(zhí)行完畢后，其實執(zhí)行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)，執(zhí)行到這，就對上了。

案例代碼

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！");

測試結(jié)果

main begin！
thread before
thread after
main end！

Process finished with exit code 0

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

• 這部分驗證的主要體現(xiàn)就是加了 thread.join() 后，會影響到輸出結(jié)果。如果不加，main end！ 會優(yōu)先 thread after 提前打印出來。
• join() 是一個 synchronized 方法，里面調(diào)用了 wait() 方法，讓持有當(dāng)前同步鎖的線程進入等待狀態(tài)，也就是主線程。當(dāng)子線程執(zhí)行完畢后，我們從源碼中可以看到 JVM 調(diào)用了 lock.notify_all(thread) 所以喚醒了主線程繼續(xù)執(zhí)行。

三、線程啟動過程

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

咳咳，Java 的線程創(chuàng)建和啟動非常簡單，但如果問一個線程是怎么啟動起來的往往并不清楚，甚至不知道為什么啟動時是調(diào)用start()，而不是調(diào)用run()方法呢？

那么，為了讓大家有一個更直觀的認(rèn)知，我們先站在上帝視角。把這段 Java 的線程代碼，到 JDK 方法使用，以及 JVM 的相應(yīng)處理過程，展示給大家，以方便我們后續(xù)逐步分析。

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

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

接下來，我們就開始逐步分析每一步源碼的執(zhí)行內(nèi)容，從而了解線程啟動過程。

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()，在它的方法英文注釋中已經(jīng)把核心內(nèi)容描述出來。Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread. 這段話的意思是：由 JVM 調(diào)用此線程的 run 方法，使線程開始執(zhí)行。其實這就是一個 JVM 的回調(diào)過程，下文源碼分析中會講到
• 另外 start() 是一個 synchronized 方法，但為了避免多次調(diào)用，在方法中會由線程狀態(tài)判斷。threadStatus != 0。
• group.add(this)，是把當(dāng)前線程加入到線程組，ThreadGroup。
• start0()，是一個本地方法，通過 JNI 方式調(diào)用執(zhí)行。這一步的操作才是啟動線程的核心步驟。

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()，這個方法是用于注冊線程執(zhí)行過程中需要的一些本地方法，比如：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 方法會執(zhí)行 &JVM_StartThread 方法，最終由 JVM 層面啟動線程。

3. JVM 創(chuàng)建線程

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;
  
  // 創(chuàng)建線程
  native_thread = new JavaThread(&thread_entry, sz);
  // 啟動線程
  Thread::start(native_thread);

JVM_END

• 這部分代碼比較多，但核心內(nèi)容主要是創(chuàng)建線程和啟動線程，另外 &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);
}

重點，在創(chuàng)建線程引入這個線程入口的方法時，thread_entry 中包括了 Java 的回調(diào)函數(shù) JavaCalls::call_virtual。這個回調(diào)函數(shù)會由 JVM 調(diào)用。

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

源碼：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 程序中會被調(diào)用的 run 方法。接下來我們繼續(xù)按照代碼執(zhí)行鏈路，尋找到這個被回調(diào)的方法在什么時候調(diào)用的。

3.2 JavaThread

native_thread = new JavaThread(&thread_entry, sz);

接下來，我們繼續(xù)看 JavaThread 的源碼執(zhí)行內(nèi)容。

源碼：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，表示進程中已有的線程個數(shù)。
• 這兩個參數(shù)，都會傳遞給 os::create_thread 方法，用于創(chuàng)建線程使用。

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 服務(wù)實現(xiàn)，Liunx 還有 Windows 等，都會實現(xiàn)線程的創(chuàng)建邏輯。這有點像適配器模式

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)，初始化已分配的狀態(tài)，但此時并沒有初始化。
• pthread_create，是類Unix操作系統(tǒng)（Unix、Linux、Mac OS X等）的創(chuàng)建線程的函數(shù)。
• java_start，重點關(guān)注類，是實際創(chuàng)建線程的方法。

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

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

  // 設(shè)置線程狀態(tài)：INITIALIZED 初始化完成
  osthread->set_state(INITIALIZED);
  
  // 喚醒所有線程
  sync->notify_all();

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

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

  return 0;
}

• JVM 設(shè)置線程狀態(tài)，INITIALIZED 初始化完成。
• sync->notify_all()，喚醒所有線程。
• osthread->get_state() == INITIALIZED，while 循環(huán)等待
• thread->run()，是等待線程喚醒后，也就是狀態(tài)變更后，才能執(zhí)行到。這在我們的線程執(zhí)行UML圖中，也有所體現(xiàn)

4. JVM 啟動線程

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

JVM_END

• JVM_StartThread 中有兩步，創(chuàng)建（new JavaThread）、啟動（Thread::start）。創(chuàng)建的過程聊完了，接下來我們聊啟動。

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()，那么設(shè)置線程狀態(tài)為 RUNNABLE。
• os::start_thread(thread)，調(diào)用線程啟動方法。不同的 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)，設(shè)置線程狀態(tài) RUNNABLE
• pd_start_thread(thread)，啟動線程，這個就由各個 OS 實現(xiàn)類，實現(xiàn)各自系統(tǒng)的啟動方法了。比如，windows系統(tǒng)和Linux系統(tǒng)的代碼是完全不同的。

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() 最關(guān)鍵，它可以喚醒線程。
• 線程喚醒后，3.4 中的 thread->run(); 就可以繼續(xù)執(zhí)行了。

5. JVM 線程回調(diào)

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()，最終調(diào)用的就是 thread.cpp 的 JavaThread::run() 方法。
• 這部分還需要繼續(xù)往下看，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;
}

• 這里有你熟悉的設(shè)置的線程名稱，this->set_native_thread_name(this->get_thread_name())。
• this->entry_point()，實際調(diào)用的就是 3.1 中的 thread_entry 方法。
• thread_entry，方法最終會調(diào)用到 JavaCalls::call_virtual 里的vmSymbols::run_method_name()。也就是 run() 方法，至此線程啟動完成。終于串回來了！

四、Thread 狀態(tài)關(guān)系

Java 的線程狀態(tài)描述在枚舉類 java.lang.Thread.State 中，共包括如下五種狀態(tài)：

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

這五種狀態(tài)描述了一個線程的生命周期，其實這種狀態(tài)碼的定義在我們?nèi)粘５臉I(yè)務(wù)開發(fā)中，也經(jīng)常出現(xiàn)。比如：一個活動的提交、審核、拒絕、修改、通過、運行、關(guān)閉等，是類似的。那么線程的狀態(tài)是通過下圖的方式進行流轉(zhuǎn)的，如圖 20-1

• New：新創(chuàng)建的一個線程，處于等待狀態(tài)。
• Runnable：可運行狀態(tài)，并不是已經(jīng)運行，具體的線程調(diào)度各操作系統(tǒng)決定。在 Runnable 中包含了 Ready、Running 兩個狀態(tài)，當(dāng)線程調(diào)用了 start() 方法后，線程則處于就緒 Ready 狀態(tài)，等待操作系統(tǒng)分配 CPU 時間片，分配后則進入 Running 運行狀態(tài)。此外當(dāng)調(diào)用 yield() 方法后，只是謙讓的允許當(dāng)前線程讓出CPU，但具體讓不讓不一定，由操作系統(tǒng)決定。如果讓了，那么當(dāng)前線程則會處于 Ready 狀態(tài)繼續(xù)競爭CPU，直至執(zhí)行。
• Timed_waiting：指定時間內(nèi)讓出CPU資源，此時線程不會被執(zhí)行，也不會被系統(tǒng)調(diào)度，直到等待時間到期后才會被執(zhí)行。下列方法都可以觸發(fā)：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil。
• Wating：可被喚醒的等待狀態(tài)，此時線程不會被執(zhí)行也不會被系統(tǒng)調(diào)度。此狀態(tài)可以通過 synchronized 獲得鎖，調(diào)用 wait 方法進入等待狀態(tài)。最后通過 notify、notifyall 喚醒。下列方法都可以觸發(fā)：Object.wait、Thread.join、LockSupport.park。
• Blocked：當(dāng)發(fā)生鎖競爭狀態(tài)下，沒有獲得鎖的線程會處于掛起狀態(tài)。例如 synchronized 鎖，先獲得的先執(zhí)行，沒有獲得的進入阻塞狀態(tài)。
• Terminated：這個是終止?fàn)顟B(tài)，從 New 到 Terminated 是不可逆的。一般是程序流程正常結(jié)束或者發(fā)生了異常。

這里參考枚舉State 類的英文注釋了解了每一個狀態(tài)碼的含義，接下來我們?nèi)L試操作線程方法，把這些狀態(tài)體現(xiàn)出來。

1. NEW

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

// NEW

• 這個狀態(tài)很簡單，就是線程創(chuàng)建還沒有啟動時就是這個狀態(tài)。

2. RUNNABLE

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

// RUNNABLE

• 創(chuàng)建的線程啟動后 start()，就會進入 RUNNABLE 狀態(tài)。但此時并不一定在執(zhí)行，而是說這個線程已經(jīng)就緒，可以競爭 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

• 這段代碼稍微有點長，主要是為了讓兩個線程發(fā)生鎖競爭。
• 第一個線程，synchronized 獲取鎖后休眠，不釋放鎖。
• 第二個線程，synchronized 獲取不到鎖，會被掛起。
• 那么最后的輸出結(jié)果就會是，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 代碼塊或者修飾的方法中，調(diào)用 wait 方法，又沒有被 notify 就會進入 WAITING 狀態(tài)。
• 另外 Thread.join 源碼中也是調(diào)用的 wait 方法，所以也會讓線程進入等待狀態(tài)。

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

• 有了上面狀態(tài)獲取的對比，這個狀態(tài)的獲取就沒什么難度了。只要改成 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

• 這個就比較簡單了，只要一個線程運行完，它的生命周期結(jié)束了，就進入了 TERMINATED 狀態(tài)。

五、總結(jié)

• 線程的啟動過程涉及到了 JVM 的參與，所以如果沒有認(rèn)真了解過，確實很難從一個本地方法了解的如此透徹。
• 整個源碼分析可以結(jié)合著代碼調(diào)用UML時序圖進行學(xué)習(xí)，基本核心過程包括：Java 創(chuàng)建線程和啟動、調(diào)用本地方法 start0()、JVM 中 JVM_StartThread 的創(chuàng)建和啟動、設(shè)置線程狀態(tài)等待被喚醒、根據(jù)不同的OS啟動線程并喚醒、最后回調(diào) run() 方法啟動 Java 線程。
• 線程狀態(tài)和狀態(tài)的轉(zhuǎn)換也是面試中必問的問題，但除了面試是我們自己在開發(fā)中，如果真的使用線程，是非常有必要了解線程狀態(tài)是如何轉(zhuǎn)換的。
• 線程的一些深入學(xué)習(xí)都是在調(diào)用本地方法，也就是需要了解到JVM層面，才能更加深刻的見到c++代碼是如何實現(xiàn)這部分邏輯的。

六、系列推薦

• 講道理，只要你是一個愛折騰的程序員，畢業(yè)找工作真的不需要再花錢培訓(xùn)！
• 工作兩年簡歷寫成這樣，誰要你呀！
• 《Java 面經(jīng)手冊》PDF，全書 417 頁 11.5 萬字，完稿&發(fā)版！
• synchronized 解毒，剖析源碼深度分析！
• BATJTMD，大廠招聘，都招什么樣Java程序員？