Java 執行緒間通信 —— 等待 / 通知機制

本文部分摘自《Java 并發編程的藝術》

volatile 和 synchronize 關鍵字

每個處于運行狀態的執行緒，如果僅僅是孤立地運行，那么它產生的作用很小，如果多個執行緒能夠相互配合完成作業，則將帶來更大的價值

Java 支持多個執行緒同時訪問一個物件或者物件的成員變數，使用 volatile 關鍵字可以保證被修飾變數的可見性，意味著任一執行緒對該變數的任何修改，其他執行緒都可以立即感知到

synchronize 關鍵字可以修飾方法或者同步塊，它主要確保多個執行緒在同一時刻，只能有一個執行緒處于方法或者同步塊中，它保證了執行緒對變數訪問的可見性和排他性，synchronize 關鍵字的實作，本質是對一個物件的監視器（monitor）進行獲取，而這個獲取程序是排他的，也就是同一時刻只能有一個執行緒獲取到由 synchronize 所保護物件的監視器

任何一個物件都擁有自己的監視器，任意一個執行緒對 Object 的訪問（Object 由 synchronize 保護）的訪問，首先要獲得 Object 的監視器，如果獲取失敗，執行緒進入同步佇列，執行緒狀態變為 BLOCKED，當訪問 Object 的前驅（獲得了鎖的執行緒）釋放了鎖，則該釋放操作將喚醒阻塞在同步佇列中的執行緒，使其重新嘗試獲取監視器

等待 - 通知機制

一個執行緒修改了一個物件的值，另一個執行緒感知到變化，然后進行相應的操作，前者是生產者，后者是消費者，這種通信方式實作了解耦，更具伸縮性，在 Java 中為了實作類似的功能，我們可以讓消費者執行緒不斷地回圈檢查變數是否符合預期，條件滿足則退出回圈，從而完成消費者的作業

while(value != desire) {
    Thread.sleep(1000);
}
doSomething();

睡眠一段時間的目的是防止過快的無效嘗試，這種實作方式看似能滿足需求，但存在兩個問題：

• 難以確保及時性

  如果睡眠時間太長，就難以及時發現條件已經變化

• 難以降低開銷

  如果降低睡眠時間，又會消耗更多的處理器資源

使用 Java 提供了內置的等待 - 通知機制能夠很好地解決上述問題，等待 - 通知的相關方法是任意 Java 物件都具備的

等待 - 通知機制，是指一個執行緒 A 呼叫了物件 O 的 wait() 方法進入等待狀態，而另一個執行緒 B 呼叫了物件 O 的 notify() 或者 notifyAll() 方法，執行緒 A 收到通知后從物件 O 的 wait() 方法回傳，進而執行后續操作，上述兩個執行緒通過物件 O 來完成互動，而物件上的 wait() 和 notify/notifyAll() 的關系就如同開關信號一樣，用來完成等待方和通知方之間的互動作業

下述例子中，創建兩個執行緒 WaitThread 和 NotifyThread，前者檢查 flag 值是否為 false，如果符合要求，進行后續操作，否則在 lock 上等待，后者在睡眠一段時間后對 lock 進行通知

public class WaitNotify {

    static boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);
        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }

    static class Wait implements Runnable {

        @Override
        public void run() {
            // 加鎖，擁有 lock 的 Monitor
            synchronized (lock) {
                // 繼續 wait，同時釋放 lock 的鎖
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + "flag is true. wait @ "
                                + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 完成作業
                System.out.println(Thread.currentThread() + "flag is false. running @ "
                    + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    static class Notify implements Runnable {

        @Override
        public void run() {
            // 加鎖，擁有 lock 的 Monitor
            synchronized (lock) {
                // 獲取 lock 的鎖，然后進行通知，通知時不會釋放 lock 的鎖
                // 直到當前執行緒釋放 lock 后，WaitThread 才能從 wait 方法中回傳
                System.out.println(Thread.currentThread() + " hold lock. notify @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }
            // 再次加鎖
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                SleepUtils.second(5);
            }
        }
    }
}

運行結果如下

上述結果的第三行和第四行順序可能會互換，下面簡單描述一下代碼的執行程序

1. WaitThread 執行緒先啟動，NotifyThread 執行緒后啟動，由于中間有睡眠一秒的操作，所以 WaitThread 執行緒首先獲得鎖
2. WaitThread 執行緒回圈判斷條件是否滿足，不滿足則呼叫執行 lock.wait() 方法，釋放 lock 物件上的鎖，進入 lock 物件的等待佇列中，進入等待狀態
3. 由于 WaitThread 執行緒釋放了鎖，所以 NotifyThread 獲得 lock 物件上的鎖，執行 lock.notifyAll() 方法，但并不會立即釋放鎖，只是通知所有等待在 lock 上的執行緒可以參與競爭鎖了（notify 也同理），并把 flag 設為 false，本段代碼執行結束，NotifyThread 執行緒釋放鎖，此時 WaitThread 執行緒和 NotifyThread 執行緒共同競爭 lock 的鎖
4. 無論誰先拿到鎖，WaitThread 執行緒和 NotifyThread 執行緒都能順利完成任務

等待 - 通知機制的經典范式

從上節的內容中，我們可以提煉出等待 - 通知機制的經典范式，該范式分為兩部分，分別針對等待方（消費方）和通知方（生產者）

等待方遵循如下原則：

• 獲取物件上的鎖
• 如果條件不滿足，呼叫物件的 wait() 方法，被通知后仍要檢查條件
• 條件滿足則執行對應的邏輯

偽代碼如下：

synchronized(物件) {
	while(條件不滿足) {
    	物件.wait();
    }
    對應的處理邏輯
}

通知方遵循如下原則：

• 獲取物件上的鎖
• 改變條件
• 通知所有等待在物件上的執行緒

偽代碼如下：

synchronized(物件) {
	改變條件
    物件.notifyAll();
}

標籤：其他

上一篇：Python資料型別和型別轉換

下一篇：C/C++編程學習：MD5演算法代碼實作