前一篇我們把線程通信這件事講清楚了:
wait()/notify()/notifyAll()到底在做什麼- 為什麼線程有時不是在“搶鎖”,而是在“等條件”
- 為什麼線程通信必須和
synchronized搭配使用 - 生產者—消費者模型裡,等待與喚醒是怎麼配合的
但當你繼續往下學 Java 併發,很快就會遇到另一個問題:
既然 synchronized 已經能加鎖,為什麼 Java 還要再提供 Lock 這套顯式鎖機制?
很多初學者第一次看到 ReentrantLock 時,都會有點疑惑:
- 這不也是加鎖嗎?
- 和
synchronized有什麼本質區別? - 平時開發到底該優先用誰?
lock()、unlock()、tryLock()、lockInterruptibly()分別適合什麼場景?Condition和前面學過的wait()/notify()又是什麼關係?
這篇文章,我就把這條線完整接上。
你可以把它理解成:
從“會用內置鎖”進階到“會選擇鎖工具”的第一步。
這篇重點講 6 件事:
synchronized和Lock的關係是什麼ReentrantLock為什麼叫“可重入鎖”- 顯式鎖比內置鎖多給了哪些能力
tryLock()、可中斷加鎖、公平鎖分別解決什麼問題Condition為什麼比wait()/notify()更靈活- 實際開發裡什麼時候該用
synchronized,什麼時候考慮ReentrantLock
你把這一篇吃透,後面再去學:
ReadWriteLockStampedLockCondition- 線程池裡的併發控制
- 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 併發裡最基礎的一組工具串起來了:
第一層:互斥
synchronizedLock
解決的是:同一時刻誰能進入臨界區。
第二層:條件協調
wait()/notify()Condition.await()/signal()
解決的是:什麼時候該等,什麼時候該繼續。
第三層:更復雜的併發組織
後面你會繼續學到:
ReadWriteLockSemaphoreCountDownLatchCyclicBarrierBlockingQueue- 線程池
這些工具本質上都在做一件事:
把多線程之間的協作規則表達得更清楚。
也就是說,併發編程不是隻會“加鎖”,而是要會設計:
- 資源怎麼互斥
- 條件怎麼等待
- 線程怎麼協調
- 風險怎麼兜底
最後總結一下
今天這篇,你可以把核心記成下面幾句。
1)synchronized 和 ReentrantLock 都能完成互斥
在最基礎的加鎖能力上,它們都能保護共享資源。
2)ReentrantLock 的價值在於“更強控制力”
它不是單純為了“再造一把鎖”,而是提供:
- 嘗試加鎖
- 超時等待
- 可中斷獲取
- 公平鎖
- 多條件隊列
3)Condition 是比 wait() / notify() 更細粒度的條件協調工具
尤其在多條件場景下,會明顯更清晰。
4)簡單場景別過度設計,複雜場景別硬撐著只用 synchronized
併發工具沒有“唯一正確答案”,只有“是否適配當前需求”。
如果你剛學到這裡,我建議你下一步繼續順著這條線往下看:
ReentrantLock和synchronized的底層差異ReadWriteLock為什麼適合“讀多寫少”BlockingQueue如何把生產者—消費者模式封裝起來- 線程池為什麼比手動創建線程更適合真實項目
如果你願意,下一篇我可以直接接著寫:
《Java 從入門到精通(十八):讀寫鎖 ReadWriteLock,為什麼“讀多寫少”的場景不該只用一把互斥鎖?》