作者：小傅哥
博客：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++代碼是如何實現這部分邏輯的。
- 在使用線程的時候一定要讓自己有一個類似多核的腦子，線程一起、生死由你！本章節就扯到這了，很多的知識都是為了整套內容體系的全面，為后續介紹其他知識打下根基。感謝！