前一篇我們把線程通信這件事講清楚了:

  • wait() / notify() / notifyAll() 到底在做什麼
  • 為什麼線程有時不是在“搶鎖”,而是在“等條件”
  • 為什麼線程通信必須和 synchronized 搭配使用
  • 生產者—消費者模型裡,等待與喚醒是怎麼配合的

但當你繼續往下學 Java 併發,很快就會遇到另一個問題:

既然 synchronized 已經能加鎖,為什麼 Java 還要再提供 Lock 這套顯式鎖機制?

很多初學者第一次看到 ReentrantLock 時,都會有點疑惑:

  • 這不也是加鎖嗎?
  • 和 synchronized 有什麼本質區別?
  • 平時開發到底該優先用誰?
  • lock()、unlock()、tryLock()、lockInterruptibly() 分別適合什麼場景?
  • Condition 和前面學過的 wait() / notify() 又是什麼關係?

這篇文章,我就把這條線完整接上。

你可以把它理解成:

從“會用內置鎖”進階到“會選擇鎖工具”的第一步。

這篇重點講 6 件事:

  1. synchronized 和 Lock 的關係是什麼
  2. ReentrantLock 為什麼叫“可重入鎖”
  3. 顯式鎖比內置鎖多給了哪些能力
  4. tryLock()、可中斷加鎖、公平鎖分別解決什麼問題
  5. Condition 為什麼比 wait() / notify() 更靈活
  6. 實際開發裡什麼時候該用 synchronized,什麼時候考慮 ReentrantLock

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

  • ReadWriteLock
  • StampedLock
  • Condition
  • 線程池裡的併發控制
  • AQS 體系下的高級併發工具

會順很多。


一、先給結論:Lock 不是替代一切,而是給你更強的控制力

很多人剛學併發時,容易把問題理解成:

  • synchronized 是老的
  • Lock 是新的
  • 所以 Lock 一定更高級、更應該優先用

這其實不對。

更準確的理解應該是:

1)synchronized 是 Java 內置的同步機制

它簡單、直接、語義穩定。

你只要寫:

synchronized (lock) {
    // 临界区代码
}

就能完成互斥控制。

2)Lock 是併發包提供的顯式鎖接口

它讓你手動控制“什麼時候加鎖、什麼時候釋放、是否嘗試獲取、是否響應中斷、是否公平排隊”等細節。

所以你可以先這樣記:

  • synchronized:夠用、簡單、適合大多數基礎同步場景
  • Lock:更靈活,適合你需要精細控制的時候

也就是說,Lock 的價值不在於“能加鎖”,而在於“能更細地控制加鎖行為”。


二、什麼叫可重入鎖?

ReentrantLock 這個類名裡最關鍵的詞,就是 Reentrant(可重入)。

那什麼叫可重入?

意思是:

同一個線程如果已經拿到了這把鎖,那麼它可以再次獲取這把鎖,而不會把自己卡死。

比如:

public class Demo {
    private final ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("进入 methodA");
            methodB();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("进入 methodB");
        } finally {
            lock.unlock();
        }
    }
}

當同一個線程先進入 methodA(),再調用 methodB() 時,它會再次成功拿到同一把鎖。

如果鎖不可重入,會發生什麼?

那線程自己會把自己堵住:

  • 第一次進來時已經持有鎖
  • 第二次再請求同一把鎖
  • 鎖不允許重複進入
  • 於是線程永遠等自己釋放

這顯然不合理。

所以無論是 synchronized,還是 ReentrantLock,本質上都支持可重入。

這也是為什麼很多遞歸調用、嵌套同步調用能正常工作的原因。


三、synchronized 和 ReentrantLock 的共同點是什麼?

先別急著看差異,先把共同點踩穩。

它們都能完成這些事:

  • 保證同一時刻只有一個線程進入臨界區
  • 保護共享數據,避免併發寫亂
  • 建立線程間的同步關係
  • 支持可重入

也就是說,在“最基本的互斥”層面,它們都能解決問題。

如果你的需求只是:

  • 一個方法同一時刻只允許一個線程執行
  • 幾行共享變量修改需要保護
  • 沒有超時、可中斷、公平性這類要求

那很多時候 synchronized 已經完全夠用了。

所以不要把 ReentrantLock 神化成“必須替代 synchronized 的標準答案”。


四、那 ReentrantLock 到底多了什麼?

這才是本文真正的重點。

ReentrantLock 相比 synchronized,最大的優勢不是“能鎖住”,而是多給了你幾種控制方式。

主要看下面這幾類。

1)可以顯式加鎖、顯式釋放

lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();
}

你會發現,它不像 synchronized 那樣靠代碼塊邊界自動釋放,而是由你自己控制。

這帶來的好處是:

  • 鎖的作用範圍更靈活
  • 可以跨多個代碼片段組織邏輯
  • 更適合一些複雜流程控制

但代價也很明顯:

如果你忘了 unlock(),就會出大問題。

所以 ReentrantLock 幾乎總要配合 try/finally 使用。

2)可以嘗試獲取鎖,而不是死等

這就是 tryLock() 的價值。

if (lock.tryLock()) {
    try {
        System.out.println("拿到锁,执行业务");
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("没拿到锁,走降级逻辑");
}

這在很多場景裡特別有用,比如:

  • 不想長期阻塞線程
  • 沒搶到鎖就直接返回
  • 想做降級、重試、跳過當前任務
  • 避免多個線程長時間堆死在某個熱點資源上

synchronized 就沒有這種“試一下,不行就算了”的語義。

3)可以設置超時等待

if (lock.tryLock(2, TimeUnit.SECONDS)) {
    try {
        System.out.println("2 秒内成功拿到锁");
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("等了 2 秒还没拿到");
}

這個能力也很實用。

因為很多真實系統裡,最怕的不是搶不到鎖,而是:

線程無限期傻等,最後把吞吐、響應時間、調用鏈全拖死。

有超時,你就能做更穩妥的策略控制。

4)可以響應中斷

這就是 lockInterruptibly() 的意義。

lock.lockInterruptibly();

它表示:

如果線程在等待鎖的過程中被中斷,那就不要繼續死等了,直接響應中斷。

這對取消任務、停止線程、超時控制都很重要。

synchronized 在等待進入監視器時,對中斷支持就沒這麼靈活。

5)可以選擇公平鎖或非公平鎖

構造 ReentrantLock 時可以這樣寫:

ReentrantLock fairLock = new ReentrantLock(true);

true 表示公平鎖。

公平鎖的意思是:

大致按等待順序來分配鎖,先等的線程更有機會先拿到。

默認是非公平鎖,吞吐通常更高,但有時可能讓某些線程等得更久。

所以你可以這樣理解:

  • 公平鎖:更講排隊秩序
  • 非公平鎖:更講性能和吞吐

不過要注意,公平不是“絕對公平”,只是儘量按規則排。


五、為什麼顯式鎖更適合複雜併發控制?

因為真實世界裡的併發問題,很多並不只是“圍一段代碼加個鎖”這麼簡單。

例如:

  • 某個線程只願意等 500ms
  • 某個後臺任務可以被取消
  • 某個資源搶不到時要走降級邏輯
  • 某類線程需要更穩定的排隊順序
  • 某組等待條件需要單獨管理,而不是所有線程混在一個等待隊列裡

這時 ReentrantLock 的優勢就出來了。

它更像是:

把“鎖”從語法糖變成一個可以編排策略的對象。

這也是為什麼在一些框架、中間件、併發容器裡,顯式鎖特別常見。


六、Condition 是什麼?為什麼它比 wait() / notify() 更靈活?

如果你學過前一篇,就會知道:

  • wait():線程等待
  • notify():喚醒一個
  • notifyAll():喚醒全部

但這套機制有個明顯侷限:

同一個鎖對象上的等待線程,默認都擠在一個等待集合裡。

很多時候這並不夠細。

比如生產者—消費者場景裡,其實經常有兩類條件:

  • 隊列不滿,生產者才能繼續放
  • 隊列不空,消費者才能繼續取

如果所有線程都在一個等待隊列裡,你經常會遇到:

  • 喚醒了“不該醒”的線程
  • 醒了以後又發現條件不滿足
  • 又繼續睡回去

效率並不好。

而 Condition 的核心價值就是:

一個鎖,可以關聯多個條件隊列。

示意寫法:

private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();

這樣:

  • 生產者可以等 notFull
  • 消費者可以等 notEmpty

彼此的等待與喚醒更精確。

這就是顯式鎖在複雜線程協調裡特別有價值的地方。


七、看一個 Condition 版生產者—消費者例子

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MessageQueue {
    private final Queue<String> 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(String message) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }

            queue.offer(message);
            System.out.println("生产消息:" + message);

            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public String take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }

            String message = queue.poll();
            System.out.println("消费消息:" + message);

            notFull.signal();
            return message;
        } finally {
            lock.unlock();
        }
    }
}

這個例子特別適合你體會 Condition 的優勢:

  • 滿了時,只讓生產者等 notFull
  • 空了時,只讓消費者等 notEmpty
  • 放入數據後,只喚醒“等著消費”的線程
  • 取走數據後,只喚醒“等著生產”的線程

相比所有線程都混用 wait() / notifyAll(),這套邏輯更清晰,也更貼近真實業務需求。


八、使用 ReentrantLock 時,最容易踩哪些坑?

這部分你最好認真看,因為實際開發裡很多問題都出在這。

1)忘記在 finally 裡釋放鎖

錯誤寫法:

lock.lock();
doSomething();
lock.unlock();

如果 doSomething() 中間拋異常,unlock() 就可能根本執行不到。

正確寫法:

lock.lock();
try {
    doSomething();
} finally {
    lock.unlock();
}

這幾乎是硬規則。

2)拿到鎖幾次,就要釋放幾次

因為它是可重入鎖。

如果同一個線程連續 lock() 了兩次,那也必須對應 unlock() 兩次,鎖才會真正釋放。

3)tryLock() 成功後也別忘了釋放

有些人覺得“這是嘗試獲取,不一定成功”,結果成功之後反而忘了 unlock()。

4)await() / signal() 也必須在持鎖狀態下調用

和 wait() / notify() 一樣,Condition 也不是隨便亂調的。

它們必須在已經持有對應鎖的前提下使用,否則會拋異常。

5)等待條件時,依然要用 while,別隨手寫成 if

像這樣:

while (queue.isEmpty()) {
    notEmpty.await();
}

不要圖省事寫成:

if (queue.isEmpty()) {
    notEmpty.await();
}

為什麼?

因為線程被喚醒後,不代表條件就一定仍然滿足。可能:

  • 有虛假喚醒
  • 有別的線程先一步改了狀態
  • 多線程競爭後,條件又失效了

所以標準寫法就是:

醒來以後重新檢查條件。


九、實際開發中,到底該優先用誰?

這是很多人最關心的問題。

我給你一個很實用的判斷原則。

優先用 synchronized 的場景

如果你只是:

  • 保護一個簡單共享變量
  • 同步一個方法或一小段臨界區
  • 不需要超時、可中斷、公平性
  • 不需要多個條件隊列

那優先用 synchronized 很合理。

原因很簡單:

  • 代碼更短
  • 出錯面更小
  • 不容易忘記釋放鎖
  • 語義更直接

考慮 ReentrantLock 的場景

如果你需要:

  • 嘗試獲取鎖(tryLock())
  • 超時獲取鎖
  • 等待鎖時響應中斷
  • 更靈活的條件隊列(Condition)
  • 公平鎖控制
  • 更復雜的併發編排

那 ReentrantLock 更合適。

所以別把選擇理解成“誰更高級”,而要理解成:

誰更適合當前問題。


十、再往前一步:這篇學完後,你腦子裡要形成什麼圖景?

到這裡,你應該已經把 Java 併發裡最基礎的一組工具串起來了:

第一層:互斥

  • synchronized
  • Lock

解決的是:同一時刻誰能進入臨界區。

第二層:條件協調

  • wait() / notify()
  • Condition.await() / signal()

解決的是:什麼時候該等,什麼時候該繼續。

第三層:更復雜的併發組織

後面你會繼續學到:

  • ReadWriteLock
  • Semaphore
  • CountDownLatch
  • CyclicBarrier
  • BlockingQueue
  • 線程池

這些工具本質上都在做一件事:

把多線程之間的協作規則表達得更清楚。

也就是說,併發編程不是隻會“加鎖”,而是要會設計:

  • 資源怎麼互斥
  • 條件怎麼等待
  • 線程怎麼協調
  • 風險怎麼兜底

最後總結一下

今天這篇,你可以把核心記成下面幾句。

1)synchronized 和 ReentrantLock 都能完成互斥

在最基礎的加鎖能力上,它們都能保護共享資源。

2)ReentrantLock 的價值在於“更強控制力”

它不是單純為了“再造一把鎖”,而是提供:

  • 嘗試加鎖
  • 超時等待
  • 可中斷獲取
  • 公平鎖
  • 多條件隊列

3)Condition 是比 wait() / notify() 更細粒度的條件協調工具

尤其在多條件場景下,會明顯更清晰。

4)簡單場景別過度設計,複雜場景別硬撐著只用 synchronized

併發工具沒有“唯一正確答案”,只有“是否適配當前需求”。


如果你剛學到這裡,我建議你下一步繼續順著這條線往下看:

  1. ReentrantLock 和 synchronized 的底層差異
  2. ReadWriteLock 為什麼適合“讀多寫少”
  3. BlockingQueue 如何把生產者—消費者模式封裝起來
  4. 線程池為什麼比手動創建線程更適合真實項目

如果你願意,下一篇我可以直接接著寫:

《Java 從入門到精通(十八):讀寫鎖 ReadWriteLock,為什麼“讀多寫少”的場景不該只用一把互斥鎖?》