Java 讀寫鎖 ReentrantReadWriteLock 源碼分析
轉自:https://www.javadoop.com/post/reentrant-read-write-lock#toc5
本文內容:讀寫鎖 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:
對於獨佔模式來說,通常就是 0 代表可獲取鎖,1 代表鎖被別人獲取了,重入例外
而共享模式下,每個線程都可以對 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 } ... }
state 的高 16 位代表讀鎖的獲取次數,包括重入次數,獲取到讀鎖一次加 1,釋放掉讀鎖一次減 1
state 的低 16 位代表寫鎖的獲取次數,因爲寫鎖是獨佔鎖,同時只能被一個線程獲得,所以它代表重入次數
每個線程都需要維護自己的 HoldCounter,記錄該線程獲取的讀鎖次數,這樣才能知道到底是不是讀鎖重入,用 ThreadLocal 屬性 readHolds 維護
cachedHoldCounter 有什麼用?其實沒什麼用,但能提示性能。將最後一次獲取讀鎖的線程的 HoldCounter 緩存到這裏,這樣比使用 ThreadLocal 性能要好一些,因爲 ThreadLocal 內部是基於 map 來查詢的。但是 cachedHoldCounter 這一個屬性畢竟只能緩存一個線程,所以它要起提升性能作用的依據就是:通常讀鎖的獲取緊隨着就是該讀鎖的釋放。我這裏可能表達不太好,但是大家應該是懂的吧。
firstReader 和 firstReaderHoldCount 有什麼用?其實也沒什麼用,但是它也能提示性能。將"第一個"獲取讀鎖的線程記錄在 firstReader 屬性中,這裏的第一個不是全局的概念,等這個 firstReader 當前代表的線程釋放掉讀鎖以後,會有後來的線程佔用這個屬性的。firstReader 和 firstReaderHoldCount 使得在讀鎖不產生競爭的情況下,記錄讀鎖重入次數非常方便快速
如果一個線程使用了 firstReader,那麼它就不需要佔用 cachedHoldCounter
個人認爲,讀寫鎖源碼中最讓初學者頭疼的就是這幾個用於提升性能的屬性了,使得大家看得雲裏霧裏的。主要是因爲 ThreadLocal 內部是通過一個 ThreadLocalMap 來操作的,會增加檢索時間。而很多場景下,執行 unlock 的線程往往就是剛剛最後一次執行 lock 的線程,中間可能沒有其他線程進行 lock。還有就是很多不怎麼會發生讀鎖競爭的場景。
上面說了這麼多,是希望能幫大家降低後面閱讀源碼的壓力,大家也可以先看看後面的,然後再慢慢體會。
前面我們好像都只說讀鎖,完全沒提到寫鎖,主要是因爲寫鎖真的是簡單很多,我也特地將寫鎖的源碼放到了後面,我們先啃下最難的讀鎖先。
讀鎖獲取
下面我就不一行一行按源碼順序說了,我們按照使用來說。
我們來看下讀鎖 ReadLock 的 lock 流程:
// ReadLockpublic void lock() { sync.acquireShared(1); }// AQSpublic 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 中。
上面的源碼分析應該說得非常詳細了,如果到這裏你不太能看懂上面的有些地方的註釋,那麼可以先往後看,然後再多看幾遍。
讀鎖釋放
下面我們看看讀鎖釋放的流程:
// ReadLockpublic void unlock() { sync.releaseShared(1); }
// Syncpublic final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) { doReleaseShared(); // 這句代碼其實喚醒 獲取寫鎖的線程,往下看就知道了 return true; } return false; }// Syncprotected 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,如果發現讀鎖和寫鎖都釋放光了,那麼喚醒後繼的獲取寫鎖的線程。
寫鎖獲取
寫鎖是獨佔鎖。
如果有讀鎖被佔用,寫鎖獲取是要進入到阻塞隊列中等待的。
// WriteLockpublic void lock() { sync.acquire(1); }// AQSpublic final void acquire(int arg) { if (!tryAcquire(arg) && // 如果 tryAcquire 失敗,那麼進入到阻塞隊列等待 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }// Syncprotected 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(); } ... }
寫鎖釋放
// WriteLockpublic void unlock() { sync.release(1); }// AQSpublic 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技術江湖】
一位阿里 Java 工程師的技術小站。作者黃小斜,專注 Java 相關技術:SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程,偶爾講點Docker、ELK,同時也分享技術乾貨和學習經驗,致力於Java全棧開發!(關注公衆號後回覆”Java“即可領取 Java基礎、進階、項目和架構師等免費學習資料,更有數據庫、分佈式、微服務等熱門技術學習視頻,內容豐富,兼顧原理和實踐,另外也將贈送作者原創的Java學習指南、Java程序員面試指南等乾貨資源)