實際工作中，為了優化性能，我們經常會使用緩存，例如緩存元數據、緩存基礎數據等，這就是一種典型的讀多寫少應用場景。緩存之所以能提升性能，一個重要的條件就是緩存的數據一定是讀多寫少的，例如元數據和基礎數據基本上不會發生變化（寫少），但是使用它們的地方卻很多（讀多）。 針對讀多寫少這種併發場景，Java... ...
實際工作中，為了優化性能，我們經常會使用緩存，例如緩存元數據、緩存基礎數據等，這就是一種典型的讀多寫少應用場景。緩存之所以能提升性能，一個重要的條件就是緩存的數據一定是讀多寫少的，例如元數據和基礎數據基本上不會發生變化（寫少），但是使用它們的地方卻很多（讀多）。
針對讀多寫少這種併發場景，Java SDK併發包提供了讀寫鎖——ReadWriteLock，非常容易使用，並且性能很好。在併發編程中，有時我們需要處理多個線程同時讀取共用資源的情況，同時還要保證在有寫操作時，對資源的訪問是互斥的。這就是讀寫鎖（ReadWriteLock）的應用場景。
什麼是讀寫鎖？
讀寫鎖是一種鎖機制，它允許多個線程可同時讀取共用資源，但在寫操作時需要互斥。讀寫鎖將讀操作與寫操作分開，以提高併發性和性能。
ReadWriteLock的特點
-
多個線程可同時讀取：在沒有寫操作的情況下，多個線程可以併發地讀取共用資源，從而提升讀取操作的性能。 -
寫操作是互斥的：寫操作會獨占鎖，確保在寫操作進行時沒有其他線程可以讀取或寫入共用資源。 -
讀寫操作之間互斥：在寫操作進行時，其他線程不能讀取或寫入，以保證數據的一致性。
讀寫鎖與互斥鎖的一個重要區別就是 讀寫鎖允許多個線程同時讀共用變數，而互斥鎖是不允許的，這是讀寫鎖在讀多寫少場景下性能優於互斥鎖的關鍵。但 讀寫鎖的寫操作是互斥的，當一個線程在寫共用變數的時候，是不允許其他線程執行寫操作和讀操作。
如何使用ReadWriteLock
Java提供了java.util.concurrent.locks包中的ReentrantReadWriteLock類來實現讀寫鎖。下麵是一個簡單的例子：
javaimport java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private int sharedData = 0;
public int readData() {
lock.readLock().lock();
try {
return sharedData;
} finally {
lock.readLock().unlock();
}
}
public void writeData(int newData) {
lock.writeLock().lock();
try {
sharedData = newData;
} finally {
lock.writeLock().unlock();
}
}
}在上面的例子中，我們創建了一個ReentrantReadWriteLock實例作為讀寫鎖。使用readLock()方法獲取讀鎖，writeLock()方法獲取寫鎖。
在讀取共用資源時，我們需要先獲取讀鎖，然後執行讀操作，最後釋放讀鎖。在寫入共用資源時，我們需要先獲取寫鎖，然後執行寫操作，最後釋放寫鎖。
要註意的是，在使用讀寫鎖時，應該根據實際需求合理地使用讀鎖和寫鎖，以便提升併發性和性能。
讀寫鎖的優勢與適用場景
-
讀多寫少：當有大量讀取操作，而寫操作較少的情況下，讀寫鎖可以提高系統的併發性和性能。 -
數據一致性要求較低：如果對共用資源的一致性要求不高，即使在讀寫操作之間出現一定的延遲或不一致，也不會對系統產生嚴重影響。 -
提升併發性和性能：讀寫鎖通過允許多個線程同時讀取共用資源，以及在寫操作時互斥地訪問資源，可以提高系統的併發性和性能。
快速實現一個緩存
下麵我們就實踐起來，用ReadWriteLock快速實現一個通用的緩存工具類。
在下麵的代碼中，我們聲明瞭一個Cache<K, V>類，其中類型參數K代表緩存里key的類型，V代表緩存里value的類型。緩存的數據保存在Cache類內部的HashMap裡面，HashMap不是線程安全的，這裡我們使用讀寫鎖ReadWriteLock 來保證其線程安全。ReadWriteLock 是一個介面，它的實現類是ReentrantReadWriteLock，通過名字你應該就能判斷出來，它是支持可重入的。下麵我們通過rwl創建了一把讀鎖和一把寫鎖。
Cache這個工具類，我們提供了兩個方法，一個是讀緩存方法get()，另一個是寫緩存方法put()。讀緩存需要用到讀鎖，讀鎖的使用和前面我們介紹的Lock的使用是相同的，都是try{}finally{}這個編程範式。寫緩存則需要用到寫鎖，寫鎖的使用和讀鎖是類似的。這樣看來，讀寫鎖的使用還是非常簡單的。
class Cache<K,V> {
final Map<K, V> m =
new HashMap<>();
final ReadWriteLock rwl =
new ReentrantReadWriteLock();
// 讀鎖
final Lock r = rwl.readLock();
// 寫鎖
final Lock w = rwl.writeLock();
// 讀緩存
V get(K key) {
r.lock();
try { return m.get(key); }
finally { r.unlock(); }
}
// 寫緩存
V put(K key, V value) {
w.lock();
try { return m.put(key, v); }
finally { w.unlock(); }
}
}如果你曾經使用過緩存的話，你應該知道 使用緩存首先要解決緩存數據的初始化問題。緩存數據的初始化，可以採用一次性載入的方式，也可以使用按需載入的方式。
如果源頭數據的數據量不大，就可以採用一次性載入的方式，這種方式最簡單（可參考下圖），只需在應用啟動的時候把源頭數據查詢出來，依次調用類似上面示例代碼中的put()方法就可以了。
緩存一次性載入示意圖
如果源頭數據量非常大，那麼就需要按需載入了，按需載入也叫懶載入，指的是只有當應用查詢緩存，並且數據不在緩存里的時候，才觸發載入源頭相關數據進緩存的操作。下麵你可以結合文中示意圖看看如何利用ReadWriteLock 來實現緩存的按需載入。
緩存按需載入示意圖
實現緩存的按需載入
文中下麵的這段代碼實現了按需載入的功能，這裡我們假設緩存的源頭是資料庫。需要註意的是，如果緩存中沒有緩存目標對象，那麼就需要從資料庫中載入，然後寫入緩存，寫緩存需要用到寫鎖，所以在代碼中的⑤處，我們調用了 w.lock() 來獲取寫鎖。
另外，還需要註意的是，在獲取寫鎖之後，我們並沒有直接去查詢資料庫，而是在代碼⑥⑦處，重新驗證了一次緩存中是否存在，再次驗證如果還是不存在，我們才去查詢資料庫並更新本地緩存。為什麼我們要再次驗證呢？
class Cache<K,V> {
final Map<K, V> m =
new HashMap<>();
final ReadWriteLock rwl =
new ReentrantReadWriteLock();
final Lock r = rwl.readLock();
final Lock w = rwl.writeLock();
V get(K key) {
V v = null;
//讀緩存
r.lock(); ①
try {
v = m.get(key); ②
} finally{
r.unlock(); ③
}
//緩存中存在，返回
if(v != null) { ④
return v;
}
//緩存中不存在，查詢資料庫
w.lock(); ⑤
try {
//再次驗證
//其他線程可能已經查詢過資料庫
v = m.get(key); ⑥
if(v == null){ ⑦
//查詢資料庫
v=省略代碼無數
m.put(key, v);
}
} finally{
w.unlock();
}
return v;
}
}原因是在高併發的場景下，有可能會有多線程競爭寫鎖。假設緩存是空的，沒有緩存任何東西，如果此時有三個線程T1、T2和T3同時調用get()方法，並且參數key也是相同的。那麼它們會同時執行到代碼⑤處，但此時只有一個線程能夠獲得寫鎖，假設是線程T1，線程T1獲取寫鎖之後查詢資料庫並更新緩存，最終釋放寫鎖。此時線程T2和T3會再有一個線程能夠獲取寫鎖，假設是T2，如果不採用再次驗證的方式，此時T2會再次查詢資料庫。T2釋放寫鎖之後，T3也會再次查詢一次資料庫。而實際上線程T1已經把緩存的值設置好了，T2、T3完全沒有必要再次查詢資料庫。所以，再次驗證的方式，能夠避免高併發場景下重覆查詢數據的問題。
讀寫鎖的升級與降級
上面按需載入的示例代碼中，在①處獲取讀鎖，在③處釋放讀鎖，那是否可以在②處的下麵增加驗證緩存並更新緩存的邏輯呢？詳細的代碼如下。
//讀緩存
r.lock(); ①
try {
v = m.get(key); ②
if (v == null) {
w.lock();
try {
//再次驗證並更新緩存
//省略詳細代碼
} finally{
w.unlock();
}
}
} finally{
r.unlock(); ③
}這樣看上去好像是沒有問題的，先是獲取讀鎖，然後再升級為寫鎖，對此還有個專業的名字，叫 鎖的升級。可惜ReadWriteLock並不支持這種升級。在上面的代碼示例中，讀鎖還沒有釋放，此時獲取寫鎖，會導致寫鎖永久等待，最終導致相關線程都被阻塞，永遠也沒有機會被喚醒。鎖的升級是不允許的，這個你一定要註意。
不過，雖然鎖的升級是不允許的，但是鎖的降級卻是允許的。以下代碼來源自ReentrantReadWriteLock的官方示例，略做了改動。你會發現在代碼①處，獲取讀鎖的時候線程還是持有寫鎖的，這種鎖的降級是支持的。
class CachedData {
Object data;
volatile boolean cacheValid;
final ReadWriteLock rwl =
new ReentrantReadWriteLock();
// 讀鎖
final Lock r = rwl.readLock();
//寫鎖
final Lock w = rwl.writeLock();
void processCachedData() {
// 獲取讀鎖
r.lock();
if (!cacheValid) {
// 釋放讀鎖，因為不允許讀鎖的升級
r.unlock();
// 獲取寫鎖
w.lock();
try {
// 再次檢查狀態
if (!cacheValid) {
data = ...
cacheValid = true;
}
// 釋放寫鎖前，降級為讀鎖
// 降級是可以的
r.lock(); ①
} finally {
// 釋放寫鎖
w.unlock();
}
}
// 此處仍然持有讀鎖
try {use(data);}
finally {r.unlock();}
}
}總結
讀寫鎖與ReentrantLock類似，還支持公平模式和非公平模式。讀鎖和寫鎖都實現了java.util.concurrent.locks.Lock介面，因此除了支持lock()方法外，還支持tryLock()、lockInterruptibly()等方法。但是需要註意的是，只有寫鎖支持條件變數，而讀鎖不支持條件變數，因此讀鎖調用newCondition()會拋出UnsupportedOperationException異常。
今天我們使用了ReadWriteLock實現了一個簡單的緩存。儘管該緩存解決了初始化問題，但未解決緩存數據與源數據的同步問題，即確保緩存數據與源數據的一致性。解決數據同步問題最簡單的方法之一是使用超時機制。超時機制意味著緩存中載入的數據並不長期有效，而是有一定時效性。當緩存數據超過時效時間後，數據在緩存中失效。對於訪問失效的緩存數據，會觸發重新從源數據載入到緩存中。
當然，也可以在源數據發生變化時快速通知緩存，但這取決於具體的場景。例如，在MySQL作為數據源時，可以通過實時解析binlog來檢測數據是否發生變化，一旦變化就將最新數據推送給緩存。另外，還有一些方案採用了資料庫和緩存雙寫的策略。
本文來自博客園，作者：古道輕風，轉載請註明原文鏈接：https://www.cnblogs.com/88223100/p/Concurrent-Programming-Series---ReadWriteLock.html
