前一篇我們已經把 Lock 和 ReentrantLock 的核心思路拆開了。
你已經知道:
synchronized是內置鎖,簡單直接ReentrantLock是顯式鎖,更靈活、更可控lock()/unlock()要成對出現,最好永遠寫在try/finally裡tryLock()、lockInterruptibly()、公平鎖這些能力,都是synchronized很難直接表達的
但講到這裡,很多人會立刻接著問下一個問題:
既然前面已經學過 wait() / notify(),現在又有了 Lock,那為什麼 Java 還要再提供一個 Condition?
而且你第一次看到它時,通常會更困惑:
Condition不就是另一套等待/喚醒機制嗎?- 它和
Object.wait()/notify()到底有什麼本質區別? - 為什麼文檔總說
Condition可以提供“多個等待隊列”? - 多個等待隊列到底解決了什麼實際問題?
- 什麼時候該繼續用
wait()/notify(),什麼時候更適合用Condition?
這些問題背後,本質上是在問:
線程通信這件事,如果從“內置監視器模型”升級到“顯式鎖模型”,到底多出來了什麼工程能力?
這篇文章我想把這件事徹底講清楚。
我會重點講 6 個問題:
Condition是什麼,它和wait()/notify()的關係是什麼- 為什麼
Condition必須和Lock一起使用 await()、signal()、signalAll()分別在做什麼- “多個等待隊列”到底比
notifyAll()強在哪裡 - 生產者—消費者模型用
Condition重寫後,為什麼更清晰 - 初學者最容易踩哪些坑
你把這一篇吃透,後面再去學:
- 阻塞隊列
- 線程池中的任務協調
ReadWriteLock- 更復雜的併發容器和同步器
會順很多。
一、先說結論:Condition 不是重複造輪子,而是把“條件等待”從內置鎖裡拆成了更可控的顯式機制
很多人第一次看到 Condition,會覺得 Java 好像又重複造了一遍 wait()/notify()。
但它真正解決的,不是“能不能等待”這個問題,而是:
當併發協作變複雜時,wait()/notify() 這套基於單一監視器等待隊列的模型,表達能力開始不夠用了。
你可以先這樣理解兩者關係:
wait()/notify()/notifyAll():是synchronized體系裡的條件等待機制await()/signal()/signalAll():是Lock體系裡的條件等待機制
它們在目標上很像:
- 條件不滿足時先等待
- 條件滿足時再喚醒
但 Condition 更強調兩件事:
- 等待邏輯顯式化
- 等待隊列可拆分
這兩點一出來,代碼的可讀性和可控性就會明顯提升。
二、為什麼有了 wait()/notify() 還不夠?真正的問題出在“只有一條等待隊列”
這個點是理解 Condition 價值的關鍵。
前面學 wait()/notify() 時,我們已經知道:
- 每個對象都可以作為鎖對象
- 調用
wait()的線程會進入這個對象關聯的等待隊列 notify()會隨機喚醒其中一個線程notifyAll()會喚醒全部線程
表面看起來沒問題。
但一旦場景稍微複雜一點,問題就出來了。
1)單監視器模型下,不同類型的等待通常會混在同一隊列裡
最經典的例子就是生產者—消費者。
假設緩衝區有界:
- 緩衝區滿了,生產者要等
- 緩衝區空了,消費者要等
這時你會發現:
“等非滿”和“等非空”其實是兩種完全不同的條件。
但如果你只用 synchronized + wait()/notifyAll(),這兩類線程往往會掛在同一把鎖對象的等待隊列裡。
於是就會出現這些問題:
- 喚醒時粒度太粗
- 明明只該喚醒消費者,卻把生產者也一起叫醒
- 很多線程被喚醒後發現條件還是不滿足,又得繼續睡回去
- 代碼邏輯越來越繞
2)notify() 往往不敢亂用,最後只能退回 notifyAll()
因為同一等待隊列裡混著不同角色的線程,你很難保證:
- 這次隨便喚醒一個,一定是對的那個
所以很多代碼最後就只能保守地寫成 notifyAll()。
這當然是安全的,但代價是:
- 喚醒過多線程
- 增加無效競爭
- 降低併發效率
Condition 的價值,正是在這裡開始體現。
它允許你把不同條件拆成不同等待隊列。
也就是說:
不是所有“等著的人”都必須擠在一個房間裡。
三、Condition 到底是什麼?可以先把它理解成“綁定在 Lock 上的條件隊列”
先看一個最小結構。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Demo {
private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
}
這裡最關鍵的一句是:
Condition condition = lock.newCondition();
它說明:
Condition 不是獨立存在的,它必須從某把 Lock 上創建出來。
為什麼?
因為條件等待本質上仍然是在圍繞同一份共享數據做協調。
只是現在:
- 互斥訪問由
Lock管 - 條件等待由
Condition管
你可以把它粗略理解成:
Lock負責“誰能進門”Condition負責“進來之後,如果條件不滿足,去哪個等候區排隊”
這比單一監視器模型清楚得多。
四、await()、signal()、signalAll() 分別在做什麼?
這三個方法和 wait()/notify()/notifyAll() 在角色上基本對應,但語義更貼近顯式鎖體系。
1)await():等待條件,並且釋放當前鎖
最核心的一點和 wait() 一樣:
線程等待時,不會一直霸佔鎖。
也就是說,線程調用 await() 後會:
- 進入該
Condition的等待隊列 - 釋放當前持有的鎖
- 暫停執行
- 等待別人
signal()或signalAll() - 被喚醒後重新競爭鎖
- 重新拿到鎖之後,才從
await()後繼續執行
這個流程很重要,因為很多人會誤以為“被喚醒就立刻繼續跑”。
其實不是。
被喚醒只是從條件隊列回到鎖競爭階段。
它還得重新拿到鎖,才能真正繼續。
2)signal():喚醒該 Condition 等待隊列中的一個線程
注意幾個關鍵詞:
- 是這個
Condition上等待的線程 - 不是所有線程
- 也不是別的
Condition上的線程
這意味著你可以精確喚醒某一類等待者。
3)signalAll():喚醒該 Condition 等待隊列中的全部線程
這和 notifyAll() 類似,但作用域更清楚:
只喚醒這個條件隊列裡的全部線程,而不是同一把鎖下所有可能等待的人。
這就是它比傳統監視器模型更精細的地方。
五、為什麼 Condition 必須和 Lock 一起使用?
這是一個很容易死記但不真正理解的點。
本質原因很簡單:
條件等待不是孤立發生的,它一定依附於共享狀態,而共享狀態又必須受到同一套互斥規則保護。
比如:
- 緩衝區是否為空
- 當前庫存是否為 0
- 某個任務是否完成
- 某個標誌位是否已更新
這些條件都不是空中飄著的概念,而是共享數據的一部分。
所以如果等待條件和訪問共享狀態不在同一把鎖保護下,線程之間的觀察就會不一致,程序也會變得不可靠。
因此標準寫法一定是:
lock.lock();
try {
while (!conditionSatisfied) {
condition.await();
}
// 执行业务逻辑
} finally {
lock.unlock();
}
你會發現,它和前面 wait() 的最佳實踐本質上很像:
- 先獲得互斥訪問權
- 檢查條件
- 不滿足就等待
- 被喚醒後重新檢查條件
- 最後執行真正邏輯
併發裡很多看起來復雜的 API,底層思想其實一直沒變。
六、為什麼 await() 前面幾乎總是 while,而不是 if?
這條規則和前面學 wait() 時一模一樣,必須繼續保留。
while (!conditionSatisfied) {
condition.await();
}
為什麼不能偷懶寫成 if?
因為線程被喚醒時,不代表條件一定已經穩定滿足。
可能出現這些情況:
1)被喚醒後,鎖還要重新競爭
你醒了,不代表你馬上執行。
在你重新拿到鎖之前,別的線程可能已經把條件改掉了。
2)可能有多個線程一起被喚醒
如果多個線程被喚醒,其中前面的線程可能先把資源拿走,後面的線程拿到鎖時條件已經不成立了。
3)防禦性寫法更安全
併發裡最穩的邏輯永遠是:
醒來之後別急著相信世界,重新檢查條件。
所以要把這個模式記死:
if是一次性判斷while是條件守衛
只要是條件等待,優先用 while。
七、最經典的例子:用 Condition 重寫生產者—消費者模型
先看代碼。
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer {
private final Queue<Integer> queue = new LinkedList<>();
private final int capacity = 5;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public void put(int value) throws InterruptedException {
lock.lock();
try {
while (queue.size() == capacity) {
notFull.await();
}
queue.offer(value);
System.out.println("生产:" + value);
notEmpty.signal();
} finally {
lock.unlock();
}
}
public int take() throws InterruptedException {
lock.lock();
try {
while (queue.isEmpty()) {
notEmpty.await();
}
int value = queue.poll();
System.out.println("消费:" + value);
notFull.signal();
return value;
} finally {
lock.unlock();
}
}
}
這段代碼的亮點,就在於它把兩種等待條件拆開了:
notFull:給生產者等notEmpty:給消費者等
這就是 Condition 最核心的工程價值。
為什麼它比 wait()/notifyAll() 更清楚?
因為你現在可以非常明確地表達:
- 隊列滿了,生產者去
notFull這邊等 - 隊列空了,消費者去
notEmpty這邊等 - 生產完一個元素,只需要叫醒“等非空”的消費者
- 消費完一個元素,只需要叫醒“等非滿”的生產者
這比傳統寫法裡所有線程混在一個等待集合裡,再靠 notifyAll() 硬喚醒,要清晰得多。
而且性能上也更合理。
因為你減少了很多不必要的喚醒和無效競爭。
八、Condition 相比 wait()/notify(),到底強在哪?
這裡可以直接做個總結。
1)等待隊列可以拆分
這是最核心的優勢。
一個 Lock 可以創建多個 Condition。
於是不同類型的等待者可以進入不同條件隊列。
2)語義更清晰
你看到:
notEmpty.await()notFull.signal()
就幾乎能直接看懂業務意圖。
相比之下,單純看到 wait() / notifyAll(),你往往還得再回頭讀上下文,猜線程在等什麼。
3)和顯式鎖體系更一致
既然前面已經用了 ReentrantLock,那繼續配套用 Condition,會比一半顯式、一半內置語義更整齊。
4)更適合複雜併發協調
當系統中有:
- 多種角色線程
- 多個等待條件
- 更細粒度喚醒需求
Condition 的優勢會越來越明顯。
九、什麼時候繼續用 wait()/notify(),什麼時候用 Condition?
這個問題初學者很常問。
我的建議其實很直接。
1)場景簡單、教學入門、邏輯不復雜:可以先用 synchronized + wait()/notify()
比如:
- 理解線程通信基本原理
- 簡單的一對一等待模型
- 併發入門練習題
這套組合的優點是:
- 概念集中
- 不用額外引入併發包 API
- 適合先把底層思想學明白
2)場景一旦進入工程化協作,尤其有多個條件時:優先考慮 Lock + Condition
比如:
- 有界緩衝區
- 多生產者多消費者
- 任務狀態切換
- 更復雜的線程協作流程
因為這時你更在意的是:
- 可讀性
- 可維護性
- 喚醒粒度
- 邏輯分層是否清晰
如果系統已經複雜起來了,還硬用一套 wait()/notifyAll() 頂著,代碼大概率會越來越亂。
十、初學者最容易踩的坑
1)沒持有鎖就調用 await() / signal()
這和沒持有監視器就調 wait() / notify() 一樣,都是違規用法。
你必須先 lock.lock(),再操作對應的 Condition。
2)await() 醒來後不重新檢查條件
這是最常見坑之一。
記住:
醒來不代表條件一定還成立。
永遠優先:
while (!条件满足) {
condition.await();
}
3)忘記在 finally 裡釋放鎖
顯式鎖最大風險之一就是:
- 你必須自己善後
所以模板最好形成肌肉記憶:
lock.lock();
try {
// 业务逻辑
} finally {
lock.unlock();
}
4)把 signal() 想成“對方立刻運行”
不是。
signal() 只是把等待線程從條件隊列裡移出來,讓它去競爭鎖。
它什麼時候真正繼續執行,還要看鎖什麼時候輪到它。
5)條件設計不清,多個線程亂用同一個 Condition
如果你明明有兩類完全不同的等待邏輯,卻還是都塞進一個 Condition,那就等於把自己又寫回了單隊列模式。
Condition 的優勢就在於拆分等待條件,別自己把它抹平了。
十一、從設計角度看:Condition 的意義不是 API 多了,而是併發意圖更明確了
很多併發工具學到最後,真正拉開水平差距的,不是“會不會背方法名”,而是:
你能不能把線程之間的協作關係表達清楚。
Condition 的設計價值,恰恰就在這裡。
它讓你把原來混在一起的邏輯拆開成:
- 哪把鎖負責互斥
- 哪個條件負責等待非空
- 哪個條件負責等待非滿
- 哪一步修改狀態
- 哪一步喚醒正確角色
當你的代碼能把這些關係寫清楚時,後面維護、排障、擴展都會輕鬆很多。
所以別把 Condition 只看成“wait() 的替代品”。
更準確地說:
它是 Java 併發裡,把“條件協調”從隱式約定變成顯式結構的一步。
十二、最後總結
這篇文章你如果只帶走幾句話,我希望是下面這幾條。
1)Condition 是 Lock 體系裡的條件等待機制
await()對應wait()signal()對應notify()signalAll()對應notifyAll()
2)它最大的優勢不是“也能等”,而是“能拆多個等待隊列”
這讓不同類型的線程等待可以分開管理,而不是都擠在同一個監視器等待集合裡。
3)條件等待的基本套路沒有變
永遠是:
- 先拿鎖
- 檢查條件
- 不滿足就等待
- 被喚醒後重新檢查條件
- 滿足了再繼續執行業務邏輯
4)while 比 if 更適合條件等待
這是併發裡必須養成的習慣。
5)簡單場景可以先用 wait()/notify(),複雜協作更適合 Condition
尤其當你有多個等待條件時,Condition 的可讀性和可維護性會明顯更強。
下一篇我會繼續接著 Java 併發這條線往下講:
ReadWriteLock 到底在解決什麼問題?為什麼有些場景下“讀多寫少”不該再用一把普通互斥鎖硬頂?
到那時你會發現,Java 併發工具並不是越學越雜,而是在圍繞一個核心問題不斷細化:
不同線程之間,到底應該怎樣既安全,又儘量高效地協作。