Java 讀寫鎖 ReentrantReadWriteLock 源碼分析

本文內容:讀寫鎖 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 的結構,它有好些嵌套類:

大家先仔細看看這張圖中的信息。然後我們把 ReadLock 和 WriteLock 的代碼提出來一起看,清晰一些:

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

從它們調用的 Sync 方法,我們可以看到: ReadLock 使用了共享模式,WriteLock 使用了獨佔模式

等等, 同一個 AQS 實例怎麼可以同時使用共享模式和獨佔模式 ???

這裏給大家回顧下 AQS,我們橫向對比下 AQS 的共享模式和獨佔模式:

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. firstReaderfirstReaderHoldCount 有什麼用?其實也沒什麼用,但是它也能提示性能。將"第一個"獲取讀鎖的線程記錄在 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 就到阻塞隊列休眠了,自己把自己弄休眠了,而且可能之後就沒人去喚醒它了。

總結

(全文完)

關鍵詞:源碼分析 Java

相關推薦:

共享鎖(S鎖)和排它鎖(X鎖)

Java併發編程之Lock

從源碼來看ReentrantLock和ReentrantReadWriteLock

ReentrantReadWriteLock源碼分析(一)

j.u.c系列(05)---之讀寫鎖:ReentrantReadWriteLock

深入淺出Java線程池ThreadExecutorPool

ThreadLocal就是這幺簡單

ReadWriteLock(讀寫鎖)源碼分析

Spring Cloud中Hystrix 線程隔離導致ThreadLocal數據丟失