本文部分摘自《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 物件都具備的
| 方法名稱 | 描述 |
|---|---|
| notify() | 通知一個在物件上等待的執行緒，使其從 wait() 方法返回，返回的前提是該執行緒獲取到了物件的鎖 |
| notifyAll() | 通知所有等待在該物件上的執行緒 |
| wait() | 呼叫該方法的執行緒進入 WAITING 狀態，只有等待另外的執行緒通知或被中斷才返回，呼叫此方法會釋放物件的鎖 |
| wait(long) | 超時等待一段時間，引數時間是毫秒 |
| wait(long, int) | 對於超時時間更細粒度的控制，可以達到納秒 |
等待 - 通知機制，是指一個執行緒 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);
}
}
}
}
執行結果如下
上述結果的第三行和第四行順序可能會互換，下面簡單描述一下程式碼的執行過程
- WaitThread 執行緒先啟動，NotifyThread 執行緒後啟動，由於中間有睡眠一秒的操作，所以 WaitThread 執行緒首先獲得鎖
- WaitThread 執行緒迴圈判斷條件是否滿足，不滿足則呼叫執行 lock.wait() 方法，釋放 lock 物件上的鎖，進入 lock 物件的等待佇列中，進入等待狀態
- 由於 WaitThread 執行緒釋放了鎖，所以 NotifyThread 獲得 lock 物件上的鎖，執行 lock.notifyAll() 方法，但並不會立即釋放鎖，只是通知所有等待在 lock 上的執行緒可以參與競爭鎖了（notify 也同理），並把 flag 設為 false，本段程式碼執行結束，NotifyThread 執行緒釋放鎖，此時 WaitThread 執行緒和 NotifyThread 執行緒共同競爭 lock 的鎖
- 無論誰先拿到鎖，WaitThread 執行緒和 NotifyThread 執行緒都能順利完成任務
等待 - 通知機制的經典正規化
從上節的內容中，我們可以提煉出等待 - 通知機制的經典正規化，該正規化分為兩部分，分別針對等待方（消費方）和通知方（生產者）
等待方遵循如下原則：
- 獲取物件上的鎖
- 如果條件不滿足，呼叫物件的 wait() 方法，被通知後仍要檢查條件
- 條件滿足則執行對應的邏輯
虛擬碼如下：
synchronized(物件) {
while(條件不滿足) {
物件.wait();
}
對應的處理邏輯
}
通知方遵循如下原則：
- 獲取物件上的鎖
- 改變條件
- 通知所有等待在物件上的執行緒
虛擬碼如下：
synchronized(物件) {
改變條件
物件.notifyAll();
}