Java中的等待喚醒機制—至少50%的工程師還沒掌握！

這是一篇走心的填坑筆記，自學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代碼塊中執行。