前一篇我們已經把 Condition 這套顯式條件隊列機制拆開了。

你已經知道:

  • Lock 不只是 synchronized 的“另一種寫法”
  • Condition 也不只是 wait()/notify() 的簡單翻版
  • 顯式鎖體系真正帶來的,是更可控的加鎖、等待和喚醒機制
  • 當線程協作開始變複雜時,Lock + Condition 往往比內置監視器模型更清晰

但講到這裡,很多人會繼續往前追一個非常實際的問題:

既然 ReentrantLock 已經很好用了,為什麼 Java 還要再提供 ReadWriteLock?

而且這個名字第一次看上去也有點抽象:

  • 什麼叫“讀寫鎖”?
  • 讀鎖和寫鎖為什麼要分開?
  • 難道一把普通互斥鎖不能同時保護讀和寫嗎?
  • 什麼時候“讀多寫少”真的能靠讀寫鎖提速,什麼時候反而會更慢?
  • ReentrantReadWriteLock 到底該怎麼用,哪些地方最容易踩坑?

這些問題背後,本質上是在問:

當共享資源的訪問模式並不是“大家都在改”,而是“很多人讀、少數人寫”時,為什麼還要堅持讓所有線程一律排隊?

這篇文章就把這件事講透。

我想重點講 6 個問題:

  1. ReadWriteLock 是為了解決什麼問題
  2. 讀鎖和寫鎖分別允許什麼、不允許什麼
  3. ReentrantReadWriteLock 的基本用法是什麼
  4. 它為什麼在“讀多寫少”場景更有價值
  5. 鎖降級、鎖升級分別是什麼意思,為什麼要小心
  6. 真實開發裡,什麼時候該用它,什麼時候別濫用

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

  • 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 裡,這個特性依然存在。

比如同一個線程在持有寫鎖時,調用另一個也需要寫鎖的方法,不會直接死鎖。

這讓分層調用更安全。

但在讀寫鎖裡,還有兩個更值得注意的行為:

  • 寫鎖持有者可以再獲取讀鎖
  • 讀鎖持有者通常不能直接安全升級成寫鎖

後面單獨講。


八、鎖降級是什麼?為什麼它是常見模式

鎖降級這個詞第一次看會有點繞。

它的意思其實是:

線程先持有寫鎖,在完成更新後,再獲取讀鎖,最後釋放寫鎖,讓自己以“讀者”身份繼續持有訪問權。

順序通常是:

  1. 獲取寫鎖
  2. 修改共享數據
  3. 獲取讀鎖
  4. 釋放寫鎖
  5. 後續以讀鎖身份繼續讀取結果

為什麼要這麼做?

因為有些場景下,線程在更新完共享狀態後,還想繼續基於“剛更新後的穩定結果”做一段只讀邏輯。

如果直接釋放寫鎖再重新拿讀鎖,中間就可能被別人插進來改掉數據。

鎖降級可以避免這個窗口問題。

示例

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)再問:現成併發容器能不能解決?

例如:

  • ConcurrentHashMap
  • CopyOnWriteArrayList
  • AtomicReference

能直接用現成方案時,通常別先手搓鎖。

5)最後才問:如果必須自己控讀寫邊界,讀寫鎖是否值得?

到這一步,才是真正適合它的時候。


十四、最後總結:讀寫鎖的價值,不在於“更高級”,而在於“更貼合訪問模式”

把這篇最核心的結論收一下。

ReadWriteLock 解決的不是“普通鎖不能保護共享數據”,而是:

普通鎖太一刀切了,它把本來可以併發的純讀操作也一起串行化了。

所以當你的場景滿足:

  • 共享數據需要保護
  • 讀遠多於寫
  • 讀線程之間的互斥已經帶來明顯成本

那麼讀寫鎖就會很有價值。

但也別神化它。

它不是併發性能的萬能鑰匙。

如果訪問模式不匹配,或者現成併發容器更合適,硬上讀寫鎖只會讓代碼更復雜。

一句話總結:

讀寫鎖不是為了讓鎖“更厲害”,而是為了讓同步策略更像真實業務裡的訪問結構。

下一篇,我們繼續往前走,講一個很容易讓人好奇、也很容易被誤用的併發工具:

StampedLock 到底比 ReadWriteLock 強在哪?樂觀讀又為什麼聽起來很美、用起來要格外小心?