前一篇我們已經把 Condition 這套顯式條件隊列機制拆開了。
你已經知道:
Lock不只是synchronized的“另一種寫法”Condition也不只是wait()/notify()的簡單翻版- 顯式鎖體系真正帶來的,是更可控的加鎖、等待和喚醒機制
- 當線程協作開始變複雜時,
Lock + Condition往往比內置監視器模型更清晰
但講到這裡,很多人會繼續往前追一個非常實際的問題:
既然 ReentrantLock 已經很好用了,為什麼 Java 還要再提供 ReadWriteLock?
而且這個名字第一次看上去也有點抽象:
- 什麼叫“讀寫鎖”?
- 讀鎖和寫鎖為什麼要分開?
- 難道一把普通互斥鎖不能同時保護讀和寫嗎?
- 什麼時候“讀多寫少”真的能靠讀寫鎖提速,什麼時候反而會更慢?
ReentrantReadWriteLock到底該怎麼用,哪些地方最容易踩坑?
這些問題背後,本質上是在問:
當共享資源的訪問模式並不是“大家都在改”,而是“很多人讀、少數人寫”時,為什麼還要堅持讓所有線程一律排隊?
這篇文章就把這件事講透。
我想重點講 6 個問題:
ReadWriteLock是為了解決什麼問題- 讀鎖和寫鎖分別允許什麼、不允許什麼
ReentrantReadWriteLock的基本用法是什麼- 它為什麼在“讀多寫少”場景更有價值
- 鎖降級、鎖升級分別是什麼意思,為什麼要小心
- 真實開發裡,什麼時候該用它,什麼時候別濫用
你把這一篇吃透,後面再去學:
StampedLock- 併發容器中的分段控制思路
- 緩存、配置中心、本地索引等典型併發設計
會順很多。
一、先說結論:ReadWriteLock 的核心目的,不是“讓鎖更復雜”,而是“讓讀操作別被無意義地互相阻塞”
很多人第一次接觸讀寫鎖時,會覺得它像是在普通鎖上又疊了一層規則。
但它真正解決的問題其實很樸素:
如果多個線程都只是讀取共享數據,並沒有修改,那它們彼此之間通常並不存在真正的衝突。
普通互斥鎖的問題在於:
- 不管你是讀還是寫
- 只要進臨界區
- 其他線程就都得等
這意味著:
- 一個線程讀配置
- 另一個線程也只是讀配置
- 結果兩個人還是得串行排隊
從“數據安全”角度看,這當然沒錯。
但從“併發效率”角度看,往往太保守了。
所以讀寫鎖的核心思想就是把訪問拆成兩類:
- 讀操作:只查看,不修改
- 寫操作:會更新共享數據
然後允許:
- 多個讀線程同時進入
- 寫線程獨佔進入
- 寫時禁止其他讀寫線程併發進入
一句話理解:
讀讀可以併發,讀寫不能併發,寫寫也不能併發。
這就是讀寫鎖最核心的規則。
二、為什麼普通互斥鎖在“讀多寫少”場景下不夠優雅?
這個問題特別值得想透。
1)普通互斥鎖把“讀”和“寫”一視同仁
比如你有一個緩存、配置表、商品信息映射或者黑名單集合。
絕大多數時候,線程做的事情可能只是:
- 查一下某個 key 在不在
- 讀一下當前配置值
- 根據共享 Map 做個判斷
真正修改數據的時刻反而很少。
如果這時你用一把普通互斥鎖,無論誰來都必須串行:
- 線程 A 讀
- 線程 B 讀
- 線程 C 還是讀
- 但它們都得排隊
這就會讓系統吞吐無謂下降。
2)“讀操作安全”不等於“讀操作免費”
有人會說,那我乾脆不加鎖,只讀總行吧?
不行。
因為“讀多寫少”並不代表“寫不存在”。
只要寫線程可能在更新共享數據,讀線程就仍然可能讀到:
- 中間態
- 不一致狀態
- 還沒發佈完成的對象
- 結構修改過程中的異常結果
所以問題不是“要不要保護讀”,而是:
能不能在保證正確性的前提下,讓多個純讀線程少互相擋路。
讀寫鎖就是在回答這個問題。
三、讀鎖和寫鎖到底怎麼協作?先把規則背熟
讀寫鎖的規則並不多,但一定要非常清楚。
1)讀鎖可以共享
如果當前沒有線程持有寫鎖,那麼多個線程可以同時持有讀鎖。
也就是說:
- 線程 A 讀
- 線程 B 也讀
- 線程 C 還是讀
它們可以一起進。
2)寫鎖必須獨佔
如果有線程要修改共享數據,那麼它拿到寫鎖後,其他線程都不能同時進入相關臨界區。
也就是說:
- 寫的時候,不允許別的寫進來
- 寫的時候,也不允許讀進來
因為寫操作最怕在修改過程中被別人看到不完整狀態。
3)只要有寫鎖,後續讀通常也得等
這是很多人一開始不適應的地方。
他們會想:
“我只是讀一下,為什麼還不能進?”
原因很簡單:
寫操作進行中,數據可能正處在變化過程裡。
如果這時放讀進來,就破壞了一致性保護。
4)是否允許寫線程插隊,取決於實現策略
在 Java 裡,最常見的實現是 ReentrantReadWriteLock。
它支持:
- 非公平模式
- 公平模式
不同模式下,讀線程和寫線程的排隊體驗會不同,後面會單獨講。
四、最常見實現:ReentrantReadWriteLock 到底怎麼用?
Java 裡最常見的讀寫鎖實現就是:
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();
你可以把它理解成:
- 一把總的讀寫鎖對象
- 從裡面拆出兩把“視圖鎖”
- 讀鎖
- 寫鎖
然後根據操作類型分別加鎖。
1)讀操作示例
public class ConfigStore {
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();
private final Map<String, String> config = new HashMap<>();
public String get(String key) {
readLock.lock();
try {
return config.get(key);
} finally {
readLock.unlock();
}
}
public void put(String key, String value) {
writeLock.lock();
try {
config.put(key, value);
} finally {
writeLock.unlock();
}
}
}
這個例子裡:
get()只是讀,所以拿讀鎖put()會改數據,所以拿寫鎖
這樣帶來的效果是:
- 多個
get()可以併發執行 put()執行時會獨佔put()與get()不會併發穿透
這就是最基本的用法。
五、為什麼它在緩存、配置、字典類場景特別常見?
因為這些場景很符合它的強項:
- 讀頻率高
- 寫頻率低
- 讀操作通常比較快
- 共享數據需要一致性保護
典型例子包括:
- 本地緩存
- 配置中心客戶端緩存
- 規則表
- 路由表
- 用戶權限快照
- 黑白名單集合
- 讀多寫少的內存索引
舉個很常見的現實判斷:
如果你的系統 95% 的請求只是查詢緩存,5% 才是刷新緩存,那麼讓這 95% 的讀線程全部互斥排隊,通常不太划算。
讀寫鎖的價值就在這裡。
六、但注意:不是所有“讀多寫少”都一定適合上讀寫鎖
這是非常重要的一句。
很多人學完讀寫鎖後,會下意識覺得:
只要讀比寫多,就應該立刻換成 ReadWriteLock。
這不對。
因為讀寫鎖不是白送收益,它也有成本。
1)鎖本身更復雜,管理開銷更高
相比一把普通互斥鎖,讀寫鎖需要維護:
- 讀者計數
- 寫者獨佔狀態
- 更復雜的喚醒與排隊邏輯
如果臨界區非常小,數據結構也很簡單,那麼這些額外開銷可能抵消掉併發收益。
2)如果寫並不稀少,收益會迅速下降
只要寫操作稍微頻繁一點,讀線程就還是會經常被擋住。
這時你會發現:
- 寫鎖一來,讀還是得停
- 系統仍然會出現明顯串行化
- 複雜度上去了,但吞吐未必明顯改善
3)如果讀操作本身特別短,鎖競爭優勢可能不明顯
比如只是讀取一個簡單字段,操作耗時極低。
這時即使允許讀併發,真正節省下來的時間也未必顯著。
4)如果數據結構本身已有更適合的併發方案,未必該自己手寫讀寫鎖
例如某些場景裡:
ConcurrentHashMap- 原子類
- copy-on-write 思路
- 不可變對象快照
可能比你手動維護一把讀寫鎖更合適。
所以判斷標準不是“讀多寫少”這四個字本身,而是:
讀操作是否真的互相阻塞得很嚴重,以及這種阻塞是否值得用更復雜的同步機制去換。
七、可重入是什麼意思?為什麼 ReentrantReadWriteLock 名字裡也有 Reentrant
前面學 ReentrantLock 時已經提過“可重入”。
這裡再複習一下:
可重入的意思是:同一個線程已經拿到某把鎖後,可以再次獲取這把鎖,而不會把自己鎖死。
在 ReentrantReadWriteLock 裡,這個特性依然存在。
比如同一個線程在持有寫鎖時,調用另一個也需要寫鎖的方法,不會直接死鎖。
這讓分層調用更安全。
但在讀寫鎖裡,還有兩個更值得注意的行為:
- 寫鎖持有者可以再獲取讀鎖
- 讀鎖持有者通常不能直接安全升級成寫鎖
後面單獨講。
八、鎖降級是什麼?為什麼它是常見模式
鎖降級這個詞第一次看會有點繞。
它的意思其實是:
線程先持有寫鎖,在完成更新後,再獲取讀鎖,最後釋放寫鎖,讓自己以“讀者”身份繼續持有訪問權。
順序通常是:
- 獲取寫鎖
- 修改共享數據
- 獲取讀鎖
- 釋放寫鎖
- 後續以讀鎖身份繼續讀取結果
為什麼要這麼做?
因為有些場景下,線程在更新完共享狀態後,還想繼續基於“剛更新後的穩定結果”做一段只讀邏輯。
如果直接釋放寫鎖再重新拿讀鎖,中間就可能被別人插進來改掉數據。
鎖降級可以避免這個窗口問題。
示例
writeLock.lock();
try {
// 更新共享数据
updateData();
readLock.lock();
} finally {
writeLock.unlock();
}
try {
// 继续读取刚刚更新后的稳定结果
useData();
} finally {
readLock.unlock();
}
這就是典型的降級:
- 寫 -> 讀
這個方向通常是允許且合理的。
九、鎖升級為什麼危險?為什麼“讀鎖升級成寫鎖”通常不推薦
所謂鎖升級,是指:
- 線程先拿了讀鎖
- 讀著讀著發現要修改數據
- 然後想在不釋放讀鎖的前提下,直接再獲取寫鎖
很多人第一次寫緩存邏輯時都容易這麼想。
但這個方向通常非常危險,甚至可能直接導致死鎖或長期等待。
為什麼?
因為寫鎖要求獨佔,而你自己手裡還拿著讀鎖。
如果系統裡還有其他讀線程也持有讀鎖,那麼大家都在讀,誰也不給寫讓路,升級就很容易卡住。
所以常見建議是:
不要指望從讀鎖平滑升級到寫鎖。
更穩的做法通常是:
- 先釋放讀鎖
- 再競爭寫鎖
- 拿到寫鎖後重新檢查條件
為什麼要“重新檢查條件”?
因為你釋放讀鎖到重新拿到寫鎖這段時間裡,數據可能已經被別人改過了。
這個思路和併發裡的很多經典規則一樣:
只要中間放開了鎖,就必須承認狀態可能變化。
十、公平鎖和非公平鎖在讀寫鎖裡怎麼理解?
ReentrantReadWriteLock 和 ReentrantLock 一樣,也支持公平/非公平策略。
1)非公平模式
默認一般是非公平。
特點是:
- 吞吐通常更高
- 線程不一定嚴格按排隊先後獲取鎖
- 更強調整體效率
2)公平模式
公平模式更強調:
- 誰先等,誰先拿
- 減少某些線程長期拿不到鎖的風險
但公平往往意味著更嚴格的排隊和更多調度成本,吞吐可能下降。
在讀寫鎖裡,一個常見擔憂是 寫線程飢餓。
比如一直有新讀線程不斷湧入,如果調度策略處理不好,寫線程可能長期等不到機會。
這也是為什麼具體是否使用公平模式,要結合業務壓測,而不是憑感覺決定。
十一、一個更像真實項目的例子:緩存延遲加載
來看一個很經典的場景:
- 大部分請求只是讀緩存
- 緩存沒命中時,需要加載並寫回
很多人會第一反應寫成:
- 先讀鎖檢查
- 沒有就升級成寫鎖
但前面說過,升級危險。
更合理的寫法通常是“雙重檢查”風格:
public class CacheService {
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();
private final Map<String, String> cache = new HashMap<>();
public String get(String key) {
readLock.lock();
try {
String value = cache.get(key);
if (value != null) {
return value;
}
} finally {
readLock.unlock();
}
writeLock.lock();
try {
String value = cache.get(key);
if (value == null) {
value = loadFromDb(key);
cache.put(key, value);
}
return value;
} finally {
writeLock.unlock();
}
}
private String loadFromDb(String key) {
return "mock-" + key;
}
}
這裡最關鍵的是第二次檢查:
String value = cache.get(key);
if (value == null) {
value = loadFromDb(key);
cache.put(key, value);
}
因為從釋放讀鎖到拿到寫鎖之間,可能已經有別的線程把數據寫進去了。
如果不重查,就容易重複加載、重複寫入,甚至引發邏輯錯誤。
十二、讀寫鎖最容易踩的坑,我建議你提前記住這幾個
1)把“讀操作”寫成了會修改狀態的操作
比如某個方法表面叫 get(),但裡面偷偷:
- 更新計數器
- 寫日誌到共享結構
- 修改緩存時間戳
這時它就不再是純讀了。
如果你還拿讀鎖,邏輯就不安全。
所以使用讀寫鎖的前提之一是:
你必須對“讀”和“寫”的邊界足夠清楚。
2)忘記在 finally 中釋放鎖
這和 ReentrantLock 一樣,是基本紀律。
lock.lock();
try {
// 业务逻辑
} finally {
lock.unlock();
}
不要圖省事。
3)錯誤嘗試鎖升級
這個前面已經說過,是高頻坑。
- 讀鎖裡別貿然去拿寫鎖
- 真要寫,就釋放讀鎖後重新競爭
- 拿到寫鎖後重新檢查狀態
4)讀寫比例根本不適合,卻硬上讀寫鎖
如果寫很多,或者臨界區很短,讀寫鎖常常收益不大,反而讓代碼更難維護。
5)誤以為它一定比 synchronized 或 ReentrantLock 快
並沒有這種絕對關係。
併發工具沒有“天然更高級就天然更快”這種事。
只有:
- 場景匹不匹配
- 競爭模式合不合適
- 壓測結果好不好看
十三、到底什麼時候該用 ReadWriteLock?給你一個實用判斷法
我自己的判斷順序通常是這樣的:
1)先問:共享數據真的需要鎖保護嗎?
如果可以用不可變對象、線程封閉、消息傳遞,那往往更簡單。
2)再問:讀是不是明顯多於寫?
不是“稍微多一點”,而是明顯多。
3)再問:多個讀線程互相阻塞,是不是已經成為性能問題?
如果根本不是瓶頸,就別急著加複雜度。
4)再問:現成併發容器能不能解決?
例如:
ConcurrentHashMapCopyOnWriteArrayListAtomicReference
能直接用現成方案時,通常別先手搓鎖。
5)最後才問:如果必須自己控讀寫邊界,讀寫鎖是否值得?
到這一步,才是真正適合它的時候。
十四、最後總結:讀寫鎖的價值,不在於“更高級”,而在於“更貼合訪問模式”
把這篇最核心的結論收一下。
ReadWriteLock 解決的不是“普通鎖不能保護共享數據”,而是:
普通鎖太一刀切了,它把本來可以併發的純讀操作也一起串行化了。
所以當你的場景滿足:
- 共享數據需要保護
- 讀遠多於寫
- 讀線程之間的互斥已經帶來明顯成本
那麼讀寫鎖就會很有價值。
但也別神化它。
它不是併發性能的萬能鑰匙。
如果訪問模式不匹配,或者現成併發容器更合適,硬上讀寫鎖只會讓代碼更復雜。
一句話總結:
讀寫鎖不是為了讓鎖“更厲害”,而是為了讓同步策略更像真實業務裡的訪問結構。
下一篇,我們繼續往前走,講一個很容易讓人好奇、也很容易被誤用的併發工具:
StampedLock 到底比 ReadWriteLock 強在哪?樂觀讀又為什麼聽起來很美、用起來要格外小心?