作者：小傅哥
部落格：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.cjvm.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cppthread.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cppos.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hppos_linux.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cppos_windows.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/windows/vm/os_windows.cppvmSymbols.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.cppos_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)，設定執行緒狀態RUNNABLEpd_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++程式碼是如何實現這部分邏輯的。