本文轉自：https://www.javadoop.com/

**本文轉載自網際網路，侵刪**

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

文章同步發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《Java併發指南》其中一篇，本文大部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何全面深入地學習Java併發技術，從Java多執行緒基礎，再到併發程式設計的基礎知識，從Java併發包的入門和實戰，再到JUC的原始碼剖析，一步步地學習Java併發程式設計，並上手進行實戰，以便讓你更完整地瞭解整個Java併發程式設計知識體系，形成自己的知識框架。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供一些對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

本文內容：讀寫鎖 ReentrantReadWriteLock 的原始碼分析，基於 Java7/Java8。

閱讀建議：雖然我這裡會介紹一些 AQS 的知識，不過如果你完全不瞭解 AQS，看本文就有點吃力了。

## 使用示例

下面這個例子非常實用，我是 javadoc 的搬運工：

```
// 這是一個關於快取操作的故事
class CachedData {
    Object data;
    volatile boolean cacheValid;
    // 讀寫鎖例項
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData() {
        // 獲取讀鎖
        rwl.readLock().lock();
        if (!cacheValid) { // 如果快取過期了，或者為 null
            // 釋放掉讀鎖，然後獲取寫鎖 (後面會看到，沒釋放掉讀鎖就獲取寫鎖，會發生死鎖情況)
            rwl.readLock().unlock();
            rwl.writeLock().lock();

try {
                if (!cacheValid) { // 重新判斷，因為在等待寫鎖的過程中，可能前面有其他寫執行緒執行過了
                    data = ...
                    cacheValid = true;
                }
                // 獲取讀鎖 (持有寫鎖的情況下，是允許獲取讀鎖的，稱為 “鎖降級”，反之不行。)
                rwl.readLock().lock();
            } finally {
                // 釋放寫鎖，此時還剩一個讀鎖
                rwl.writeLock().unlock(); // Unlock write, still hold read
            }
        }

try {
            use(data);
        } finally {
            // 釋放讀鎖
            rwl.readLock().unlock();
        }
    }
}
```

ReentrantReadWriteLock 分為讀鎖和寫鎖兩個例項，讀鎖是共享鎖，可被多個執行緒同時使用，寫鎖是獨佔鎖。持有寫鎖的執行緒可以繼續獲取讀鎖，反之不行。

## ReentrantReadWriteLock 總覽

這一節比較重要，我們要先看清楚 ReentrantReadWriteLock 的大框架，然後再到原始碼細節。

首先，我們來看下 ReentrantReadWriteLock 的結構，它有好些巢狀類：

![11](https://www.javadoop.com/blogimages/reentrant-read-write-lock/11.png)

大家先仔細看看這張圖中的資訊。然後我們把 ReadLock 和 WriteLock 的程式碼提出來一起看，清晰一些：

![12](https://www.javadoop.com/blogimages/reentrant-read-write-lock/12.png)

很清楚了，ReadLock 和 WriteLock 中的方法都是透過 Sync 這個類來實現的。Sync 是 AQS 的子類，然後再派生了公平模式和不公平模式。

從它們呼叫的 Sync 方法，我們可以看到： **ReadLock 使用了共享模式，WriteLock 使用了獨佔模式**。

等等，**同一個 AQS 例項怎麼可以同時使用共享模式和獨佔模式**？？？

這裡給大家回顧下 AQS，我們橫向對比下 AQS 的共享模式和獨佔模式：

![13](https://www.javadoop.com/blogimages/reentrant-read-write-lock/13.png)

AQS 的精髓在於內部的屬性 **state**：

1.  對於獨佔模式來說，通常就是 0 代表可獲取鎖，1 代表鎖被別人獲取了，重入例外
2.  而共享模式下，每個執行緒都可以對 state 進行加減操作

也就是說，獨佔模式和共享模式對於 state 的操作完全不一樣，那讀寫鎖 ReentrantReadWriteLock 中是怎麼使用 state 的呢？答案是**將 state 這個 32 位的 int 值分為高 16 位和低 16位，分別用於共享模式和獨佔模式**。

## 原始碼分析

有了前面的概念，大家心裡應該都有數了吧，下面就不再那麼囉嗦了，直接程式碼分析。

原始碼加註釋 1500 行，並不算難，我們要看的程式碼量不大。如果你前面一節都理解了，那麼直接從頭開始一行一行往下看就是了，還是比較簡單的。

ReentrantReadWriteLock 的前面幾行很簡單，我們往下滑到 Sync 類，先來看下它的所有的屬性：

```
abstract static class Sync extends AbstractQueuedSynchronizer {
    // 下面這塊說的就是將 state 一分為二，高 16 位用於共享模式，低16位用於獨佔模式
    static final int SHARED_SHIFT   = 16;
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
    // 取 c 的高 16 位值，代表讀鎖的獲取次數(包括重入)
    static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
    // 取 c 的低 16 位值，代表寫鎖的重入次數，因為寫鎖是獨佔模式
    static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

// 這個巢狀類的例項用來記錄每個執行緒持有的讀鎖數量(讀鎖重入)
    static final class HoldCounter {
        // 持有的讀鎖數
        int count = 0;
        // 執行緒 id
        final long tid = getThreadId(Thread.currentThread());
    }

// ThreadLocal 的子類
    static final class ThreadLocalHoldCounter
        extends ThreadLocal<holdcounter> {
        public HoldCounter initialValue() {
            return new HoldCounter();
        }
    }
    /**
      * 組合使用上面兩個類，用一個 ThreadLocal 來記錄當前執行緒持有的讀鎖數量
      */ 
    private transient ThreadLocalHoldCounter readHolds;

// 用於快取，記錄"最後一個獲取讀鎖的執行緒"的讀鎖重入次數，
    // 所以不管哪個執行緒獲取到讀鎖後，就把這個值佔為已用，這樣就不用到 ThreadLocal 中查詢 map 了
    // 算不上理論的依據：通常讀鎖的獲取很快就會伴隨著釋放，
    //   顯然，在 獲取->釋放 讀鎖這段時間，如果沒有其他執行緒獲取讀鎖的話，此快取就能幫助提高效能
    private transient HoldCounter cachedHoldCounter;

// 第一個獲取讀鎖的執行緒(並且其未釋放讀鎖)，以及它持有的讀鎖數量
    private transient Thread firstReader = null;
    private transient int firstReaderHoldCount;

Sync() {
        // 初始化 readHolds 這個 ThreadLocal 屬性
        readHolds = new ThreadLocalHoldCounter();
        // 為了保證 readHolds 的記憶體可見性
        setState(getState()); // ensures visibility of readHolds
    }
    ...
}
```

1.  state 的高 16 位代表讀鎖的獲取次數，包括重入次數，獲取到讀鎖一次加 1，釋放掉讀鎖一次減 1
2.  state 的低 16 位代表寫鎖的獲取次數，因為寫鎖是獨佔鎖，同時只能被一個執行緒獲得，所以它代表重入次數
3.  每個執行緒都需要維護自己的 HoldCounter，記錄該執行緒獲取的讀鎖次數，這樣才能知道到底是不是讀鎖重入，用 ThreadLocal 屬性 **readHolds** 維護
4.  **cachedHoldCounter** 有什麼用？其實沒什麼用，但能提示效能。將最後一次獲取讀鎖的執行緒的 HoldCounter 快取到這裡，這樣比使用 ThreadLocal 效能要好一些，因為 ThreadLocal 內部是基於 map 來查詢的。但是 cachedHoldCounter 這一個屬性畢竟只能快取一個執行緒，所以它要起提升效能作用的依據就是：通常讀鎖的獲取緊隨著就是該讀鎖的釋放。我這裡可能表達不太好，但是大家應該是懂的吧。
5.  **firstReader** 和 **firstReaderHoldCount** 有什麼用？其實也沒什麼用，但是它也能提示效能。將"第一個"獲取讀鎖的執行緒記錄在 firstReader 屬性中，這裡的**第一個**不是全域性的概念，等這個 firstReader 當前代表的執行緒釋放掉讀鎖以後，會有後來的執行緒佔用這個屬性的。**firstReader 和 firstReaderHoldCount 使得在讀鎖不產生競爭的情況下，記錄讀鎖重入次數非常方便快速**
6.  如果一個執行緒使用了 firstReader，那麼它就不需要佔用 cachedHoldCounter
7.  個人認為，讀寫鎖原始碼中最讓初學者頭疼的就是這幾個用於提升效能的屬性了，使得大家看得雲裡霧裡的。主要是因為 ThreadLocal 內部是透過一個 ThreadLocalMap 來操作的，會增加檢索時間。而很多場景下，執行 unlock 的執行緒往往就是剛剛最後一次執行 lock 的執行緒，中間可能沒有其他執行緒進行 lock。還有就是很多不怎麼會發生讀鎖競爭的場景。

上面說了這麼多，是希望能幫大家降低後面閱讀原始碼的壓力，大家也可以先看看後面的，然後再慢慢體會。

前面我們好像都只說讀鎖，完全沒提到寫鎖，主要是因為寫鎖真的是簡單很多，我也特地將寫鎖的原始碼放到了後面，我們先啃下最難的讀鎖先。

### 讀鎖獲取

下面我就不一行一行按原始碼順序說了，我們按照使用來說。

我們來看下讀鎖 ReadLock 的 lock 流程：

```
// ReadLock
public void lock() {
    sync.acquireShared(1);
}
// AQS
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}
```

然後我們就會進到 Sync 類的 tryAcquireShared 方法：

> 在 AQS 中，如果 tryAcquireShared(arg) 方法返回值小於 0 代表沒有獲取到共享鎖(讀鎖)，大於 0 代表獲取到
> 
> 回顧 AQS 共享模式：tryAcquireShared 方法不僅僅在 acquireShared 的最開始被使用，這裡是 try，也就可能會失敗，如果失敗的話，執行後面的 doAcquireShared，進入到阻塞佇列，然後等待前驅節點喚醒。喚醒以後，還是會呼叫 tryAcquireShared 進行獲取共享鎖的。當然，喚醒以後再 try 是很容易獲得鎖的，因為這個節點已經排了很久的隊了，組織是會照顧它的。
> 
> 所以，你在看下面這段程式碼的時候，要想象到兩種獲取讀鎖的場景，一種是新來的，一種是排隊排到它的。

```
protected final int tryAcquireShared(int unused) {

Thread current = Thread.currentThread();
    int c = getState();

// exclusiveCount(c) 不等於 0，說明有執行緒持有寫鎖，
    //    而且不是當前執行緒持有寫鎖，那麼當前執行緒獲取讀鎖失敗
    //         （另，如果持有寫鎖的是當前執行緒，是可以繼續獲取讀鎖的）
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;

// 讀鎖的獲取次數
    int r = sharedCount(c);

// 讀鎖獲取是否需要被阻塞，稍後細說。為了進去下面的分支，假設這裡不阻塞就好了
    if (!readerShouldBlock() &&
        // 判斷是否會溢位 (2^16-1，沒那麼容易溢位的)
        r < MAX_COUNT &&
        // 下面這行 CAS 是將 state 屬性的高 16 位加 1，低 16 位不變，如果成功就代表獲取到了讀鎖
        compareAndSetState(c, c + SHARED_UNIT)) {

// =======================
        //   進到這裡就是獲取到了讀鎖
        // =======================

if (r == 0) {
            // r == 0 說明此執行緒是第一個獲取讀鎖的，或者說在它前面獲取讀鎖的都走光光了，它也算是第一個吧
            //  記錄 firstReader 為當前執行緒，及其持有的讀鎖數量：1
            firstReader = current;
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            // 進來這裡，說明是 firstReader 重入獲取讀鎖（這非常簡單，count 加 1 結束）
            firstReaderHoldCount++;
        } else {
            // 前面我們說了 cachedHoldCounter 用於快取最後一個獲取讀鎖的執行緒
            // 如果 cachedHoldCounter 快取的不是當前執行緒，設定為快取當前執行緒的 HoldCounter
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0) 
                // 到這裡，那麼就是 cachedHoldCounter 快取的是當前執行緒，但是 count 為 0，
                // 大家可以思考一下：這裡為什麼要 set ThreadLocal 呢？(當然，答案肯定不在這塊程式碼中)
                //   既然 cachedHoldCounter 快取的是當前執行緒，
                //   當前執行緒肯定呼叫過 readHolds.get() 進行初始化 ThreadLocal
                readHolds.set(rh);

// count 加 1
            rh.count++;
        }
        // return 大於 0 的數，代表獲取到了共享鎖
        return 1;
    }
    // 往下看
    return fullTryAcquireShared(current);
}
```

上面的程式碼中，要進入 if 分支，需要滿足：readerShouldBlock() 返回 false，並且 CAS 要成功（我們先不要糾結 MAX_COUNT 溢位）。

那我們反向推，怎麼樣進入到最後的 fullTryAcquireShared：

*   readerShouldBlock() 返回 true，2 種情況：

*   在 FairSync 中說的是 hasQueuedPredecessors()，即阻塞佇列中有其他元素在等待鎖。

> 也就是說，公平模式下，有人在排隊呢，你新來的不能直接獲取鎖

*   在 NonFairSync 中說的是 apparentlyFirstQueuedIsExclusive()，即判斷阻塞佇列中 head 的第一個後繼節點是否是來獲取寫鎖的，如果是的話，讓這個寫鎖先來，避免寫鎖飢餓。

> 作者給寫鎖定義了更高的優先順序，所以如果碰上獲取寫鎖的執行緒**馬上**就要獲取到鎖了，獲取讀鎖的執行緒不應該和它搶。
        > 
        > 如果 head.next 不是來獲取寫鎖的，那麼可以隨便搶，因為是非公平模式，大家比比 CAS 速度

*   compareAndSetState(c, c + SHARED_UNIT) 這裡 CAS 失敗，存在競爭。可能是和另一個讀鎖獲取競爭，當然也可能是和另一個寫鎖獲取操作競爭。

然後就會來到 fullTryAcquireShared 中再次嘗試：

```
/**
 * 1\. 剛剛我們說了可能是因為 CAS 失敗，如果就此返回，那麼就要進入到阻塞佇列了，
 *    想想有點不甘心，因為都已經滿足了 !readerShouldBlock()，也就是說本來可以不用到阻塞佇列的，
 *    所以進到這個方法其實是增加 CAS 成功的機會
 * 2\. 在 NonFairSync 情況下，雖然 head.next 是獲取寫鎖的，我知道它等待很久了，我沒想和它搶，
 *    可是如果我是來重入讀鎖的，那麼只能表示對不起了
 */
final int fullTryAcquireShared(Thread current) {
    HoldCounter rh = null;
    // 別忘了這外層有個 for 迴圈
    for (;;) {
        int c = getState();
        // 如果其他執行緒持有了寫鎖，自然這次是獲取不到讀鎖了，乖乖到阻塞佇列排隊吧
        if (exclusiveCount(c) != 0) {
            if (getExclusiveOwnerThread() != current)
                return -1;
            // else we hold the exclusive lock; blocking here
            // would cause deadlock.
        } else if (readerShouldBlock()) {
            /**
              * 進來這裡，說明：
              *  1\. exclusiveCount(c) == 0：寫鎖沒有被佔用
              *  2\. readerShouldBlock() 為 true，說明阻塞佇列中有其他執行緒在等待
              *
              * 既然 should block，那進來這裡是幹什麼的呢？
              * 答案：是進來處理讀鎖重入的！
              * 
              */

// firstReader 執行緒重入讀鎖，直接到下面的 CAS
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
            } else {
                if (rh == null) {
                    rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current)) {
                        // cachedHoldCounter 快取的不是當前執行緒
                        // 那麼到 ThreadLocal 中獲取當前執行緒的 HoldCounter
                        // 如果當前執行緒從來沒有初始化過 ThreadLocal 中的值，get() 會執行初始化
                        rh = readHolds.get();
                        // 如果發現 count == 0，也就是說，純屬上一行程式碼初始化的，那麼執行 remove
                        // 然後往下兩三行，乖乖排隊去
                        if (rh.count == 0)
                            readHolds.remove();
                    }
                }
                if (rh.count == 0)
                    // 排隊去。
                    return -1;
            }
            /**
              * 這塊程式碼我看了蠻久才把握好它是幹嘛的，原來只需要知道，它是處理重入的就可以了。
              * 就是為了確保讀鎖重入操作能成功，而不是被塞到阻塞佇列中等待
              *
              * 另一個資訊就是，這裡對於 ThreadLocal 變數 readHolds 的處理：
              *    如果 get() 後發現 count == 0，居然會做 remove() 操作，
              *    這行程式碼對於理解其他程式碼是有幫助的
              */
        }

if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");

if (compareAndSetState(c, c + SHARED_UNIT)) {
            // 這裡 CAS 成功，那麼就意味著成功獲取讀鎖了
            // 下面需要做的是設定 firstReader 或 cachedHoldCounter

if (sharedCount(c) == 0) {
                // 如果發現 sharedCount(c) 等於 0，就將當前執行緒設定為 firstReader
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                // 下面這幾行，就是將 cachedHoldCounter 設定為當前執行緒
                if (rh == null)
                    rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                else if (rh.count == 0)
                    readHolds.set(rh);
                rh.count++;
                cachedHoldCounter = rh;
            }
            // 返回大於 0 的數，代表獲取到了讀鎖
            return 1;
        }
    }
}
```

> firstReader 是每次將**讀鎖獲取次數**從 0 變為 1 的那個執行緒。
> 
> 能快取到 firstReader 中就不要快取到 cachedHoldCounter 中。

上面的原始碼分析應該說得非常詳細了，如果到這裡你不太能看懂上面的有些地方的註釋，那麼可以先往後看，然後再多看幾遍。

### 讀鎖釋放

下面我們看看讀鎖釋放的流程：

```
// ReadLock
public void unlock() {
    sync.releaseShared(1);
}
```

```
// Sync
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared(); // 這句程式碼其實喚醒 獲取寫鎖的執行緒，往下看就知道了
        return true;
    }
    return false;
}

// Sync
protected final boolean tryReleaseShared(int unused) {
    Thread current = Thread.currentThread();
    if (firstReader == current) {
        if (firstReaderHoldCount == 1)
            // 如果等於 1，那麼這次解鎖後就不再持有鎖了，把 firstReader 置為 null，給後來的執行緒用
            // 為什麼不順便設定 firstReaderHoldCount = 0？因為沒必要，其他執行緒使用的時候自己會設值
            firstReader = null;
        else
            firstReaderHoldCount--;
    } else {
        // 判斷 cachedHoldCounter 是否快取的是當前執行緒，不是的話要到 ThreadLocal 中取
        HoldCounter rh = cachedHoldCounter;
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();

int count = rh.count;
        if (count <= 1) {

// 這一步將 ThreadLocal remove 掉，防止記憶體洩漏。因為已經不再持有讀鎖了
            readHolds.remove();

if (count <= 0)
                // 就是那種，lock() 一次，unlock() 好幾次的逗比
                throw unmatchedUnlockException();
        }
        // count 減 1
        --rh.count;
    }

for (;;) {
        int c = getState();
        // nextc 是 state 高 16 位減 1 後的值
        int nextc = c - SHARED_UNIT;
        if (compareAndSetState(c, nextc))
            // 如果 nextc == 0，那就是 state 全部 32 位都為 0，也就是讀鎖和寫鎖都空了
            // 此時這裡返回 true 的話，其實是幫助喚醒後繼節點中的獲取寫鎖的執行緒
            return nextc == 0;
    }
}
```

讀鎖釋放的過程還是比較簡單的，主要就是將 hold count 減 1，如果減到 0 的話，還要將 ThreadLocal 中的 remove 掉。

然後是在 for 迴圈中將 state 的高 16 位減 1，如果發現讀鎖和寫鎖都釋放光了，那麼喚醒後繼的獲取寫鎖的執行緒。

### 寫鎖獲取

1.  寫鎖是獨佔鎖。
2.  如果有讀鎖被佔用，寫鎖獲取是要進入到阻塞佇列中等待的。

```
// WriteLock
public void lock() {
    sync.acquire(1);
}
// AQS
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        // 如果 tryAcquire 失敗，那麼進入到阻塞佇列等待
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// Sync
protected final boolean tryAcquire(int acquires) {

Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {

// 看下這裡返回 false 的情況：
        //   c != 0 && w == 0: 寫鎖可用，但是有執行緒持有讀鎖(也可能是自己持有)
        //   c != 0 && w !=0 && current != getExclusiveOwnerThread(): 其他執行緒持有寫鎖
        //   也就是說，只要有讀鎖或寫鎖被佔用，這次就不能獲取到寫鎖
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;

if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");

// 這裡不需要 CAS，仔細看就知道了，能到這裡的，只可能是寫鎖重入，不然在上面的 if 就攔截了
        setState(c + acquires);
        return true;
    }

// 如果寫鎖獲取不需要 block，那麼進行 CAS，成功就代表獲取到了寫鎖
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}
```

下面看一眼 **writerShouldBlock()** 的判定，然後你再回去看一篇寫鎖獲取過程。

```
static final class NonfairSync extends Sync {
    // 如果是非公平模式，那麼 lock 的時候就可以直接用 CAS 去搶鎖，搶不到再排隊
    final boolean writerShouldBlock() {
        return false; // writers can always barge
    }
    ...
}
static final class FairSync extends Sync {
    final boolean writerShouldBlock() {
        // 如果是公平模式，那麼如果阻塞佇列有執行緒等待的話，就乖乖去排隊
        return hasQueuedPredecessors();
    }
    ...
}
```

### 寫鎖釋放

```
// WriteLock
public void unlock() {
    sync.release(1);
}

// AQS
public final boolean release(int arg) {
    // 1\. 釋放鎖
    if (tryRelease(arg)) {
        // 2\. 如果獨佔鎖釋放"完全"，喚醒後繼節點
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// Sync 
// 釋放鎖，是執行緒安全的，因為寫鎖是獨佔鎖，具有排他性
// 實現很簡單，state 減 1 就是了
protected final boolean tryRelease(int releases) {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    int nextc = getState() - releases;
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
        setExclusiveOwnerThread(null);
    setState(nextc);
    // 如果 exclusiveCount(nextc) == 0，也就是說包括重入的，所有的寫鎖都釋放了，
    // 那麼返回 true，這樣會進行喚醒後繼節點的操作。
    return free;
}
```

看到這裡，是不是發現寫鎖相對於讀鎖來說要簡單很多。

## 鎖降級

Doug Lea 沒有說寫鎖更**高階**，如果有執行緒持有讀鎖，那麼寫鎖獲取也需要等待。

不過從原始碼中也可以看出，確實會給寫鎖一些特殊照顧，如非公平模式下，為了提高吞吐量，lock 的時候會先 CAS 競爭一下，能成功就代表讀鎖獲取成功了，但是如果發現 head.next 是獲取寫鎖的執行緒，就不會去做 CAS 操作。

Doug Lea 將持有寫鎖的執行緒，去獲取讀鎖的過程稱為**鎖降級（Lock downgrading）**。這樣，此執行緒就既持有寫鎖又持有讀鎖。

但是，**鎖升級**是不可以的。執行緒持有讀鎖的話，在沒釋放的情況下不能去獲取寫鎖，因為會發生**死鎖**。

回去看下寫鎖獲取的原始碼：

```
protected final boolean tryAcquire(int acquires) {

Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        // 看下這裡返回 false 的情況：
        //   c != 0 && w == 0: 寫鎖可用，但是有執行緒持有讀鎖(也可能是自己持有)
        //   c != 0 && w !=0 && current != getExclusiveOwnerThread(): 其他執行緒持有寫鎖
        //   也就是說，只要有讀鎖或寫鎖被佔用，這次就不能獲取到寫鎖
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        ...
    }
    ...
}
```

仔細想想，如果執行緒 a 先獲取了讀鎖，然後獲取寫鎖，那麼執行緒 a 就到阻塞佇列休眠了，自己把自己弄休眠了，而且可能之後就沒人去喚醒它了。

## 總結

![14](https://www.javadoop.com/blogimages/reentrant-read-write-lock/14.png)

（全文完）</holdcounter>

Java併發指南9：AQS共享模式與併發工具類的實現

相關文章