這是一篇走心的填坑筆記，自學Java的幾年總是在不斷學習新的技術，一路走來發現自己踩坑無數，而填上的坑卻屈指可數。突然發現，有時候真的不是幾年工作經驗的問題，有些東西即使工作十年，沒有用心去學習過也不過是一個10年大坑罷了（真實感受）。

剛開始接觸多執行緒時，就知道有等待/喚醒這個東西，寫過一個demo就再也沒有看過了，至於它到底是個什麼東西，或者說它能解決什麼樣的問題，估計大多數人和我一樣都是模稜兩可。這次筆者就嘗試帶你搞懂等待/喚醒機制，讀完本文你將get到以下幾點：

1. 迴圈等待帶來什麼樣的問題
2. 用等待喚醒機制優化迴圈等待
3. 等待喚醒機制中的被忽略的細節

一,迴圈等待問題

假設今天要發工資，強老闆要去吃一頓好的，整個就餐流程可以分為以下幾個步驟：

1. 點餐
2. 視窗等待出餐
3. 就餐

  public static void main(String[] args) {
     // 是否還有包子
        AtomicBoolean hasBun = new AtomicBoolean();
        
        // 包子鋪老闆
        new Thread(() -> {
            try {
                // 一直迴圈檢視是否還有包子
                while (true) {
                    if (hasBun.get()) {
                        System.out.println("老闆：檢查一下是否還剩下包子...");
                        Thread.sleep(3000);
                    } else {
                        System.out.println("老闆：沒有包子了, 馬上開始製作...");
                        Thread.sleep(1000);
                        System.out.println("老闆：包子出鍋咯....");
                        hasBun.set(true);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();


        new Thread(() -> {
            System.out.println("小強：我要買包子...");
            try {
                // 每隔一段時間詢問是否完成
                while (!hasBun.get()) {
                    System.out.println("小強：包子咋還沒做好呢~");
                    Thread.sleep(3000);
                }
                System.out.println("小強：終於吃上包子了....");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
 

在上文程式碼中存在一個很大的問題，就是老闆需要不斷的去檢查是否還有包子，而客戶則需要隔一段時間去看催一下老闆，這顯然時不合理的，這就是典型的迴圈等待問題。

這種問題的程式碼中通常是如下這種模式：

   while (條件不滿足) {
       Thread.sleep(3000);
   }
   doSomething();

對應到計算機中，則暴露了一個問題：不斷通過輪詢機制來檢測條件是否成立， 如果輪詢時間過小則會浪費CPU資源，如果間隔過大，又導致不能及時獲取想要的資源。

二，等待/喚醒機制

為了解決迴圈等待消耗CPU以及資訊及時性問題，Java中提供了等待喚醒機制。通俗來講就是由主動變為被動， 當條件成立時，主動通知對應的執行緒，而不是讓執行緒本身來詢問。

2.1 基本概念

等待/喚醒機制，又叫等待通知（筆者更喜歡叫喚醒而非通知），是指執行緒A呼叫了物件O的wait()方法進入了等待狀態，而另一個執行緒呼叫了O的notify()或者notifyAll()方法，執行緒A收到通知後從物件O的wait()方法返回，進而執行後續操作。

上訴過程是通過物件O，使得執行緒A和執行緒B之間進行通訊, 線上程中呼叫了物件O的wait()方法後執行緒久進入了阻塞狀態，而在其他執行緒中物件O呼叫notify()或notifyAll方法時，則會喚醒對應的阻塞執行緒。

2.2 基本API

等待/喚醒機制的相關方法時任意Java物件具備的，因為這些方法被定義在所有Java物件的超類Object中。

notify： 通知一個在物件上等待的執行緒，使其從wait()方法返回，而返回的前提時該執行緒獲取到物件的鎖

notifyAll: 通知所有等待在該物件上的執行緒

wait: 呼叫此方法的執行緒進入阻塞等待狀態，只有等待另外執行緒的通知或者被中斷才會返回，呼叫wait方法會釋放物件的鎖

wait(long) : 等待超過一段時間沒有被喚醒就超時自動返回，單位時毫秒。

2.3 用等待喚醒機制優化迴圈等待

public static void main(String[] args) {
   // 是否還有包子
        AtomicBoolean hasBun = new AtomicBoolean();
        // 鎖物件
        Object lockObject = new Object();

        // 包子鋪老闆
        new Thread(() -> {
            try {
                while (true) {
                    synchronized (lockObject) {
                        if (hasBun.get()) {
                            System.out.println("老闆：包子夠賣了，打一把王者榮耀");
                            lockObject.wait(); 
                        } else {
                            System.out.println("老闆：沒有包子了, 馬上開始製作...");
                            Thread.sleep(3000);
                            System.out.println("老闆：包子出鍋咯....");
                            hasBun.set(true);
                            // 通知等待的食客
                            lockObject.notifyAll();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();


        new Thread(() -> {
            System.out.println("小強：我要買包子...");
            try {
                synchronized (lockObject) {
                    if (!hasBun.get()) {
                        System.out.println("小強：看一下有沒有做好， 看公眾號cruder有沒有新文章");
                        lockObject.wait(); 
                    } else {
                        System.out.println("小強：包子終於做好了，我要吃光它們....");
                        hasBun.set(false);
                        lockObject.notifyAll();
                        System.out.println("小強：一口氣把店裡包子吃光了， 快快樂樂去板磚了~~");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
 }

上述流程，減少了輪詢檢查的操作，並且執行緒呼叫wait()方法後，會釋放鎖，不會消耗CPU資源，進而提高了程式的效能。

三，等待喚醒機制的基本正規化

等待、喚醒是執行緒間通訊的手段之一，用來協調多個執行緒操作同一個資料來源。實際應用中通常用來優化迴圈等待的問題，針對等待方和通知方，可以提煉出如下的經典範式。

需要注意的是，在等待方執行的邏輯中，一定要用while迴圈來判斷等待條件，因為執行notify/notifyAll方法時只是讓等待執行緒從wait方法返回，而非重新進入臨界區

/**
 * 等待方執行的邏輯
 * 1. 獲取物件的鎖
 * 2. 檢查條件，如果條件不滿足，呼叫物件的wait方法，被通知後重新檢查條件
 * 3. 條件滿足則執行對應的邏輯
 */
synchronized(物件){
    while(條件不滿足){
        物件.wait()
    }
    doSomething();
}
/**
 * ！！ 通知方執行的邏輯
 * 1. 獲取物件的鎖
 * 2. 改變條件
 * 3. 通知(所有)等待在物件上的執行緒
 */
synchronized(物件){
    條件改變
    物件.notify();
}

這個程式設計正規化通常是針對典型的通知方和等待方，有時雙方可能具有雙重身份，即使等待方又是通知方，正如我們上文中的案例一樣。

四，notify/notifyAll不釋放鎖

相信這個問題有半數工程師都不知道，當執行wait()方法，鎖自動被釋放；但執行完notify()方法後，鎖不會釋放，而是要執行notify()方法所在的synchronized程式碼塊後才會釋放。這一點很重要，也是很多工程師容易忽略的地方。

lockObject.notifyAll();
System.out.println("小強：一口氣把店裡包子吃光了， 快快樂樂去板磚了~~");

案例程式碼中，故意設定成先notifyAll，然後在列印；上文圖中的結果也印證了了我們的描述，感興趣的小夥伴可以動手執行一下案例程式碼哦。

五，等待、喚醒必須先獲取鎖

在等待、喚醒程式設計正規化中的wait，notify，notifyAll方法往往不能直接呼叫， 需要在獲取鎖之後的臨界區執行

並且只能喚醒等待在同一把鎖上的執行緒。

當執行緒呼叫wait方法時會被加入到一個等待佇列，當執行notify時會喚醒佇列中第一個等待執行緒(等待時間最長的執行緒)，而呼叫notifyAll時則會喚醒等待執行緒中所有的等待執行緒。

六，sleep不釋放鎖 而wait 釋放

在用等待喚醒機制優化迴圈等待的過程中，有一個重要的特徵就是原本的sleep()方法用wait()方法取代，他們的最大的區別在於wait方法會釋放鎖，而sleep不會，除此之外，還有個重要的區別，sleep是Thread的方法，可以在任意地方執行；而wait是Object物件的方法，必須在synchronized程式碼塊中執行。

相關推薦