前一篇我們把線程通信這件事拆開講清楚了:
- 線程同步解決的是“別同時亂改”
- 線程通信解決的是“條件沒到先等,條件到了再繼續”
wait()/notify()為什麼必須和synchronized一起使用- 為什麼等待條件時更推薦
while而不是if - 生產者—消費者模型為什麼是併發入門的經典訓練場
但學到這裡,很多人很快會冒出一個新問題:
既然 Java 已經有 synchronized 了,為什麼後面還要學 Lock?
而且你一看代碼,可能會更疑惑:
synchronized已經能保證互斥,為什麼還要手動lock()/unlock()?ReentrantLock到底“高級”在哪裡?- 什麼叫可重入?它和
synchronized有什麼共同點? - 公平鎖、可中斷加鎖、嘗試加鎖到底是什麼意思?
- 真實開發裡,什麼時候該用
synchronized,什麼時候更適合ReentrantLock?
這些問題背後,本質上是在問:
Java 的併發控制,為什麼會同時保留“內置鎖”和“顯式鎖”兩套方案?
這篇文章就把這件事講透。
我想重點回答 6 個問題:
Lock接口是為了解決什麼問題ReentrantLock和synchronized的共同點與差異- 什麼叫“可重入”,為什麼它很重要
lock()、unlock()、tryLock()、lockInterruptibly()分別適合什麼場景- 公平鎖和非公平鎖到底怎麼理解
- 初學者最容易踩哪些坑
你把這一篇吃透,後面再去學:
ConditionReadWriteLockStampedLock- 併發容器和線程池中的鎖設計
會順很多。
一、先說結論:Lock 不是為了替代 synchronized,而是為了提供更可控的加鎖能力
很多人第一次學 Lock,會下意識把它理解成“更高級版 synchronized”。
這個理解不算錯,但不夠準確。
更好的說法是:
synchronized 是 Java 語言內置的同步機制,語法簡單、夠用、穩定;Lock 是併發包提供的顯式鎖方案,重點在於更靈活、更可控。
它們都能解決互斥問題,但設計目標並不完全一樣。
1)synchronized 的特點是簡單
你寫上關鍵字,JVM 就會幫你完成:
- 進入同步區前獲取鎖
- 離開同步區後自動釋放鎖
- 即使出現異常,也會自動釋放
所以它特別適合:
- 併發入門
- 邏輯簡單的臨界區保護
- 鎖範圍比較清晰的場景
2)Lock 的特點是顯式控制
用 Lock 時,你需要自己寫:
- 什麼時候加鎖
- 什麼時候釋放鎖
- 是否嘗試加鎖
- 是否響應中斷
- 是否使用公平策略
- 是否拆分多個等待條件
這聽起來更麻煩,但也意味著你獲得了更多控制能力。
所以 Lock 不是“為了把簡單事情寫複雜”,而是:
當併發控制需求比 synchronized 更復雜時,給你更多工程化手段。
二、先看最基礎寫法:ReentrantLock 到底怎麼用?
先別急著比較,先把最基本的使用方式看清楚。
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
這個寫法裡最關鍵的是兩件事:
1)先 lock() 再進關鍵區
這和 synchronized 的目標一致:
- 同一時刻只允許一個線程進入關鍵區
2)一定要在 finally 裡 unlock()
這是使用顯式鎖最重要的習慣之一。
因為和 synchronized 不一樣,Lock 不會幫你自動釋放鎖。
如果你中途異常退出,卻忘了 unlock(),那其他線程可能就一直卡住。
所以入門階段先把這條規則記死:
lock() 後面幾乎總是立刻跟一個 try/finally。
三、什麼叫可重入?為什麼 ReentrantLock 這個名字裡就帶著它?
“可重入”這個詞聽起來有點抽象,但意思其實不難。
它指的是:
同一個線程如果已經拿到了某把鎖,那麼它再次請求這把鎖時,不會被自己阻塞。
先看一個例子。
public class Demo {
public synchronized void methodA() {
methodB();
}
public synchronized void methodB() {
System.out.println("methodB 执行");
}
}
這裡 methodA() 調用了 methodB(),而兩個方法都加了 synchronized。
如果鎖不可重入,會發生什麼?
- 當前線程進入
methodA(),拿到鎖 - 執行到
methodB()時,再次申請同一把鎖 - 如果不允許重入,線程會把自己卡死
Java 顯然不能這麼設計。
所以無論是 synchronized,還是 ReentrantLock,本質上都支持可重入。
為什麼可重入很重要?
因為真實代碼裡,方法調用經常是層層嵌套的:
- 一個同步方法調另一個同步方法
- 子類方法調用父類同步邏輯
- 業務邏輯拆成多個內部輔助方法
如果鎖不能重入,很多正常的程序結構都會出問題。
所以“可重入”不是錦上添花,而是併發鎖設計裡的基礎能力。
四、ReentrantLock 和 synchronized 有哪些共同點?
別一上來只盯差異,它們其實有很多共同點。
1)都能保證互斥訪問
同一時刻,只有一個線程能進入關鍵區。
2)都支持可重入
同一個線程拿到鎖之後,可以再次進入受同一把鎖保護的代碼。
3)都能用於保護共享資源
比如:
- 計數器
- 庫存
- 訂單狀態
- 緩衝區
- 賬戶餘額
4)都不是“越多越好”
只要涉及鎖,就意味著:
- 有等待
- 有競爭
- 有可能影響吞吐
所以無論用哪一種,本質目標都還是:
用可接受的併發成本,換正確性和一致性。
五、那為什麼還需要 ReentrantLock?因為它提供了 synchronized 不擅長的幾種能力
這才是這篇最核心的部分。
1)可以嘗試加鎖,而不是無限死等
synchronized 的特點是:
- 要麼拿到鎖進去
- 要麼拿不到就一直等
但 ReentrantLock 可以這樣寫:
if (lock.tryLock()) {
try {
// 拿到锁再执行
} finally {
lock.unlock();
}
} else {
System.out.println("没有拿到锁,先做别的事");
}
這在一些業務裡非常實用。
比如:
- 不想讓線程長時間阻塞
- 想快速失敗、稍後重試
- 某些任務拿不到鎖就直接放棄
這類需求用 synchronized 就不夠靈活。
2)可以響應中斷地等待鎖
有時線程在等鎖時,不應該傻等到底。
如果外部已經決定取消這個任務,希望線程別繼續等,就需要“可中斷加鎖”。
lock.lockInterruptibly();
這表示:
- 如果鎖可用,就獲取鎖
- 如果當前在等待鎖時被中斷,就停止等待並拋出異常
這種能力在:
- 任務取消
- 超時控制
- 線程池中的複雜任務協調
裡非常實用。
而 synchronized 在等待進入監視器這件事上,控制力就沒這麼細。
3)可以指定公平鎖或非公平鎖
ReentrantLock 可以這樣創建:
ReentrantLock fairLock = new ReentrantLock(true);
這裡的 true 表示公平鎖。
公平鎖的大致含義是:
儘量按照等待時間先後順序分配鎖。
而非公平鎖則更強調吞吐,允許“插隊”現象更容易發生。
一般來說:
- 公平鎖更講秩序
- 非公平鎖通常吞吐更高
synchronized 對這一層控制就沒有這麼顯式。
4)可以配合多個 Condition 做更精細的線程協調
前一篇我們講了 wait() / notify()。
但它們有個侷限:
- 等待隊列是基於對象監視器來管理的
- 同一把鎖上的條件管理不夠精細
而 ReentrantLock 可以配合 Condition,讓不同線程等不同條件。
比如:
- 生產者等“隊列未滿”
- 消費者等“隊列非空”
這會比單純 notifyAll() 更清晰、更容易擴展。
這也是為什麼很多稍複雜一點的併發協作場景,會逐步從 synchronized 過渡到 Lock + Condition。
六、公平鎖和非公平鎖到底怎麼理解?
這是 ReentrantLock 裡一個很容易被問到、但很多教程講得太抽象的點。
1)公平鎖:先來先服務
你可以把它想成排隊買票。
- 誰先排隊
- 誰先得到服務
這種策略的優點是:
- 更公平
- 不容易讓某些線程長時間餓著
缺點是:
- 調度更保守
- 吞吐通常沒那麼高
2)非公平鎖:誰搶到誰先上
這更像搶電梯。
雖然有人已經等了一會兒,但一個剛來的線程如果運氣好,也可能先拿到鎖。
優點是:
- 性能通常更好
- 吞吐更高
缺點是:
- 某些線程理論上可能等更久
工程上怎麼選?
絕大多數普通業務裡:
- 默認非公平鎖就夠了
只有在你明確關心:
- 等待順序
- 線程飢餓
- 某些任務長期拿不到鎖不合理
時,才需要認真評估公平鎖。
別把公平鎖當成“更高級的默認選項”。
它只是另一種取捨。
七、tryLock() 為什麼很實用?它讓你能把“阻塞”改成“決策”
這是 ReentrantLock 相比 synchronized 很有代表性的一點。
看一個簡單例子:
public void doTask() {
if (lock.tryLock()) {
try {
System.out.println(Thread.currentThread().getName() + " 拿到锁,开始执行");
} finally {
lock.unlock();
}
} else {
System.out.println(Thread.currentThread().getName() + " 没拿到锁,稍后再试");
}
}
這段代碼表達的意思是:
- 拿到鎖就執行
- 拿不到鎖就別堵著,先走別的邏輯
這個思路在很多真實場景裡非常有價值,比如:
- 定時任務不希望重複執行
- 某個資源正在被佔用時,當前請求直接返回“稍後再試”
- 某些後臺清理任務拿不到鎖就跳過本輪
所以 tryLock() 的意義不只是“多了一個 API”,而是:
你可以把“等鎖”從被動阻塞,變成主動決策。
八、lockInterruptibly() 適合什麼場景?
這個 API 很多初學者會略過去,但它非常體現顯式鎖的工程價值。
先看問題背景。
有些線程在等鎖時,如果系統已經不需要它繼續等了,就應該儘快退出。
例如:
- 用戶取消了請求
- 上層任務已經超時
- 線程池準備關閉
- 當前線程只是候選任務,不值得一直等
這時如果你還讓線程無限等待鎖,就不太合理。
lockInterruptibly() 的價值就在於:
線程在等待鎖的過程中,可以響應中斷信號。
這意味著系統可以更主動地取消和清理任務,而不是讓線程卡在那兒傻等。
對初學者來說,你先記住這句就夠了:
lock()更適合“必須拿到鎖再幹”lockInterruptibly()更適合“等待過程中允許被取消”
九、synchronized 和 ReentrantLock 到底該怎麼選?
這是最實用的問題。
我的建議很直接:
1)如果只是基礎互斥,優先考慮 synchronized
比如:
- 保護一個計數器
- 保護一個共享集合的簡單修改
- 某個實例方法的併發互斥
- 併發教學和基礎練習
原因很簡單:
- 語法短
- 可讀性好
- 不容易忘記釋放鎖
- 足夠穩定
2)如果你明確需要更靈活的控制,再考慮 ReentrantLock
比如你需要:
- 嘗試獲取鎖
- 等鎖時響應中斷
- 指定公平策略
- 多個條件隊列
- 更復雜的併發協調邏輯
這時 ReentrantLock 的優勢才真正體現出來。
3)別把“更靈活”誤解成“應該默認優先用”
有些人學完 ReentrantLock 後,會覺得它更專業,於是恨不得所有同步都改成顯式鎖。
這通常沒必要。
因為它的靈活,伴隨的是:
- 樣板代碼更多
- 忘記釋放鎖的風險更高
- 心智負擔更重
所以最穩妥的原則通常是:
簡單互斥用 synchronized,複雜控制用 ReentrantLock。
十、一個簡單對比例子:兩種寫法長什麼樣?
用 synchronized
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
特點:
- 寫法簡潔
- 不容易出錯
- 鎖釋放由 JVM 兜底
用 ReentrantLock
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
特點:
- 更囉嗦一些
- 但後續擴展空間更大
- 可以進一步加
tryLock()、公平鎖、Condition等能力
如果當前只是“保護 count++”,那前者通常就夠了。
如果後面還要做複雜等待控制,後者會更有擴展性。
十一、初學者最容易踩的 8 個坑
1)lock() 之後忘記 unlock()
這是最經典也最危險的錯誤。
一旦忘記釋放鎖,其他線程可能長期阻塞。
2)不把 unlock() 放進 finally
如果中間拋異常,鎖就可能洩漏。
3)把 ReentrantLock 當成“默認更高級所以必須用”
不是。
很多簡單場景 synchronized 更合適。
4)對公平鎖有誤解
公平鎖不是“更先進”,只是“更講順序”。
通常還會犧牲一部分吞吐。
5)看見 tryLock() 就到處用
如果業務本來就必須拿到鎖,強行 tryLock() 反而會把邏輯搞繞。
6)忘了可重入的前提是“同一個線程”
可重入不是說所有線程都能重複進,而是當前持鎖線程可以再次進入。
7)混淆“鎖對象一致”和“代碼位置接近”
無論是 synchronized 還是 ReentrantLock,真正產生互斥的前提都是:
- 多個線程競爭的是同一把鎖
8)沒搞清楚自己為什麼不用 synchronized
如果你答不上來“為什麼這裡必須用 ReentrantLock”,那往往說明這裡並不一定真的需要它。
十二、你應該怎麼建立對顯式鎖的正確理解?
如果你現在正從 synchronized 過渡到 Lock,我建議按這個順序理解。
第一步:先承認兩者都能做互斥
別把 ReentrantLock 神化成完全不同的東西。
它首先也是鎖。
第二步:再看它多出來的控制能力
重點盯住這幾個問題:
- 能不能嘗試獲取鎖
- 能不能響應中斷
- 能不能指定公平策略
- 能不能拆分不同條件等待隊列
這才是它的價值所在。
第三步:最後再決定是否值得引入
不是每段併發代碼都值得用更復雜的工具。
工程裡更重要的不是“會更多 API”,而是:
用最合適、最穩的方案解決當前問題。
十三、最後總結:ReentrantLock 的價值,不是取代 synchronized,而是給複雜併發場景更多操作空間
如果只用一句話總結這篇,我會說:
synchronized 更像默認內置鎖,適合簡單直接的互斥;ReentrantLock 更像顯式併發工具,適合需要更細控制的場景。
你這篇真正應該帶走的,是下面這幾個核心認識:
1)ReentrantLock 和 synchronized 都支持互斥和可重入
所以它們不是完全割裂的兩套世界。
2)可重入的意思,是同一個線程拿到鎖後還能再次進入同一把鎖保護的代碼
這保證了嵌套調用不會把自己鎖死。
3)ReentrantLock 的優勢,在於它提供了更強的控制力
比如:
tryLock()lockInterruptibly()- 公平鎖
- 後續配合
Condition
4)顯式鎖最重要的紀律,是 lock() 後一定配 try/finally
否則非常容易出事故。
5)選型時別追求“誰更高級”,而要看“誰更適合當前複雜度”
簡單互斥用 synchronized,複雜控制再用 ReentrantLock,通常就是很穩的思路。
從這裡開始,你對 Java 併發的理解,就從“會用內置鎖”進一步走到了“會用顯式鎖做更細粒度控制”。
下一篇,最自然的繼續方向就是:
Condition 到底是什麼?為什麼有了 wait() / notify(),Java 還要提供條件隊列這套機制?