前一篇我們已經把 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 個問題:

  1. Condition 是什麼,它和 wait()/notify() 的關係是什麼
  2. 為什麼 Condition 必須和 Lock 一起使用
  3. await()、signal()、signalAll() 分別在做什麼
  4. “多個等待隊列”到底比 notifyAll() 強在哪裡
  5. 生產者—消費者模型用 Condition 重寫後,為什麼更清晰
  6. 初學者最容易踩哪些坑

你把這一篇吃透,後面再去學:

  • 阻塞隊列
  • 線程池中的任務協調
  • 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 併發工具並不是越學越雜,而是在圍繞一個核心問題不斷細化:

不同線程之間,到底應該怎樣既安全,又儘量高效地協作。