作者：小傅哥
部落格：https://bugstack.cn
Github：https://github.com/fuzhengwei/CodeGuide/wiki
沉澱、分享、成長，讓自己和他人都能有所收穫！?
一、前言
考不常用的、考你不會的、考你忽略的，才是考試！
大部分考試考的，基本都是不怎麼用的。例外的我們們不說? 就像你做程式開發，尤其在RPC+MQ+分庫分表，其實很難出現讓你用一個機器例項編寫多執行緒壓榨CPU效能。很多時候是扔出一個MQ，非同步消費了。如果沒有資源競爭，例如庫表秒殺，那麼其實你確實很難接觸多併發程式設計以及鎖的使用。
但！凡有例外，比如你需要開發一個資料庫路由中介軟體，那麼就肯定會出現在一臺應用例項上分配資料庫資源池的情況，如果出現競爭就要合理分配資源。如此，類似這樣的中介軟體開發，就會涉及到一些更核心底層的技術的應用。
所以，有時候不是沒用，而是你沒有用。
二、面試題
謝飛機，小記！ 執行緒我玩定了，面試也攔不住我，我說的！
謝飛機：嘿，你好哇，我是謝飛機！
面試官：好，今天電話面試，你準備好了？
謝飛機：準備好了，嘿嘿！
面試官：嗯，我看你簡歷裡寫了不少執行緒的東西，看來了解的不錯。問你一個執行緒吧那就，執行緒之間狀態是怎麼轉換的？
謝飛機：扒拉扒拉，扒拉扒拉！
面試官：嗯，還不錯。那 yield 方法是怎麼使用的。
謝飛機：嗯！好像是讓出CPU。具體的沒怎麼用過！
面試官：做做測試，驗證下，下次問你。
三、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 類的英文註釋瞭解了每一個狀態碼的含義，接下來我們去嘗試操作執行緒方法，把這些狀態體現出來。
四、Thread 狀態測試
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狀態。
五、Thread 方法使用
一般情況下 Thread 中最常用的方法就是 start 啟動，除此之外一些其他方法可能在平常的開發中用的不多，但這些方法在一些框架中卻經常出現。因此只瞭解它們的概念，但是卻缺少一些例項來參考！ 接下來我們就來做一些案例來驗證這些方法，包括：yield、wait、notify、join。
1. 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
執行緒編號：31 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：34 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：12 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：16 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：13 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：17 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：20 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：23 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：21 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：25 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：24 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：28 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：38 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：39 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：37 執行完成耗時：1 (毫秒)不讓CPU
執行緒編號：40 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：44 執行完成耗時：0 (毫秒)不讓CPU
執行緒編號：36 執行完成耗時：1 (毫秒)不讓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毫秒以上，說明我們的測試是效果的。
2. wait & notify
wait 和 notify/nofityall，是一對方法，有一個等待，就會有一個叫醒，否則程式就夯在那不動了。關於這部分會使用到的 synchronized 在之前小傅哥有深入的原始碼分析，講到它是怎麼加鎖在物件頭的，如果你忘記了可以翻翻看 《synchronized 解毒，剖析原始碼深度分析！》
接下來我們模擬鹿鼎記·麗春院，清倌喝茶吟詩聊風月日常。當有達官貴人來時，需要分配清倌給大老爺。中間會有一些等待、叫醒操作。只為讓你更好的記住這樣的案例，不要想歪嘍。清倌人即是隻賣藝歡場人，喊麥的。
案例程式碼
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，這兩個方法的使用。我相信你一定能記住這個例子！
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) 所以喚醒了主執行緒繼續執行。
六、總結
- 執行緒狀態和狀態的轉換也是面試中必問的問題，但除了面試是我們自己在開發中，如果真的使用執行緒，是非常有必要了解執行緒狀態是如何轉換的。模模糊糊的使用，總會覺得擔心，那麼你是個好程式設計師！
- 執行緒的一些深入學習都是在呼叫本地方法，也就是需要了解到JVM層面，才能更加深刻的見到c++程式碼是如何實現這部分邏輯的。
- 在使用執行緒的時候一定要讓自己有一個類似多核的腦子，執行緒一起、生死由你！本章節就扯到這了，很多的知識都是為了整套內容體系的全面，為後續介紹其他知識打下根基。感謝！