ReentrantReadWriteLock 是一個讀寫鎖，允許多個讀或者一個寫線程在執行。

內部的 Sync 繼承自 AQS，這個 Sync 包含一個共享讀鎖 ReadLock 和一個獨占寫鎖 WriteLock。

該鎖可以設置公平和非公平，默認非公平。

一個持有寫鎖的線程可以獲取讀鎖。如果該線程先持有寫鎖，再持有讀鎖并釋放寫鎖，稱為鎖降級。

WriteLock支持Condition并且與ReentrantLock語義一致，而ReadLock則不能使用Condition，否則拋出UnsupportedOperationException異常。

public class ReentrantReadWriteLock implements ReadWriteLock { /** 讀鎖 */ private final ReentrantReadWriteLock.ReadLock readerLock; /** 寫鎖 */ private final ReentrantReadWriteLock.WriteLock writerLock; /** 持有的AQS子類對象 */ final Sync sync; abstract static class Sync extends AbstractQueuedSynchronizer {} static final class NonfairSync extends Sync {} static final class FairSync extends Sync {} public static class ReadLock implements Lock {} public static class WriteLock implements Lock {} //默認非公平 public ReentrantReadWriteLock() {this(false); } public ReentrantReadWriteLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();readerLock = new ReadLock(this);writerLock = new WriteLock(this); } public static class ReadLock implements Lock { private final Sync sync;protected ReadLock(ReentrantReadWriteLock lock) { sync = lock.sync;} } public static class WriteLock implements Lock { private final Sync sync;protected WriteLock(ReentrantReadWriteLock lock) { sync = lock.sync;} }}1.2 state

Sync 繼承了 AQS，其中有一個 int 的成員變量 state，int 共32位，這里將其視為兩部分，高16位表示讀的數量，低16位表示寫的數量，這里的數量表示線程重入后的總數量。

abstract static class Sync extends AbstractQueuedSynchronizer { //繼承的一個int的成員變量，將其拆分為高16位和低16位 //private volatile int state; 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; //讀的數量 static int sharedCount(int c) { return c >>> SHARED_SHIFT; } //寫的數量 static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }}1.3 HoldCounter

讀鎖使用了一個 ThreadLocal<HoldCounter> 讓每個線程有一個線程私有的 HoldCounter，HoldCounter包含一個線程 id 以及讀重入的次數。

查找對應線程的HoldCounter 其實只用一個 ThreadLocalHoldCounter 也足夠了。這里為了加快查詢，用了兩個額外的緩存，即 cachedHoldCounter、firstReader 和 firstReaderHoldCount（后兩個組合起來相當于一個 HoldCounter）。

在讀鎖的相關操作中，先檢查 firstReader 是否為當前線程，否則檢查 cachedHoldCounter 內部的線程是否為當前線程，如果失敗最后會通過 readHolds 來獲取當前線程的 HoldCounter。

static final class HoldCounter { int count = 0; // 使用線程id，而不是線程的引用。這樣可以防止垃圾不被回收 final long tid = getThreadId(Thread.currentThread());}static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> { public HoldCounter initialValue() {return new HoldCounter(); }}//使用的ThreadLocalprivate transient ThreadLocalHoldCounter readHolds;//一個緩存private transient HoldCounter cachedHoldCounter;//組合起來相當于一個緩存private transient Thread firstReader = null;private transient int firstReaderHoldCount;二、讀鎖2.1 讀鎖的獲取

下面講解 tryAcquireShared 和 tryReadLock，tryReadLock 是一種直接搶占的非公平獲取，和 tryAcquireShared 中的非公平獲取有所不同。

根據注釋

1.檢查是否存在其他線程持有的寫鎖，是的話失敗，返回 -1；

2.判斷在當前公平狀態下能否讀，以及是否超過讀的最大數量，滿足條件則嘗試 CAS 修改狀態，讓 state 加一個單位的讀 SHARED_UNIT；修改成功后會根據三種情況，即首次讀、firstReader 是當前線程，以及其他情況分別進行處理，成功，返回1；

3.前面未返回結果，會執行 fullTryAcquireShared。

可以將該方法視為 fullTryAcquireShared 的一次快速嘗試，如果嘗試失敗，會在 fullTryAcquireShared 的自旋中一直執行，直到返回成功或者失敗。

//ReadLockpublic void lock() { sync.acquireShared(1);} //AQSpublic final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0)doAcquireShared(arg);} //Syncprotected final int tryAcquireShared(int unused) { /* * Walkthrough: * 1. If write lock held by another thread, fail. * 2. Otherwise, this thread is eligible for * lock wrt state, so ask if it should block * because of queue policy. If not, try * to grant by CASing state and updating count. * Note that step does not check for reentrant * acquires, which is postponed to full version * to avoid having to check hold count in * the more typical non-reentrant case. * 3. If step 2 fails either because thread * apparently not eligible or CAS fails or count * saturated, chain to version with full retry loop. */ Thread current = Thread.currentThread(); int c = getState(); // 如果寫的數量不是0，且寫線程不是當前線程，失敗 if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current)return -1; // 獲取讀的個數 int r = sharedCount(c); // 如果當前線程想要讀，沒有被堵塞 // 當前讀的數量未超過最大允許的讀的個數 // CAS執行成功 if (!readerShouldBlock() &&r < MAX_COUNT &&compareAndSetState(c, c + SHARED_UNIT)) { // 第一次讀，修改firstReader和firstReaderHoldCount if (r == 0) { firstReader = current; firstReaderHoldCount = 1; // 如果當前線程正好是firstReader} else if (firstReader == current) { firstReaderHoldCount++; // 其他情況，經過一系列處理后，使得rh為當前線程的HoldCounter // 對rh的記數加一} else { HoldCounter rh = cachedHoldCounter; // 如果cached為null或者不是當前線程 if (rh == null || rh.tid != getThreadId(current)) // 從readHolds中get，并修改cachedcachedHoldCounter = rh = readHolds.get(); // 如果cached不是null，但記數為null // 這種情況表示當前線程的HoldCounter已經被刪除，即為null， // 但cached仍然保留著null之前的那個HoldCounter， // 為了方便，直接將cached設置給ThreadLocal即可 else if (rh.count == 0)readHolds.set(rh); //執行到這里，rh表示當前線程的HoldCounter，記數加1 rh.count++;}return 1; } // 前面未返回結果，執行第三步 return fullTryAcquireShared(current);}2.1.2 fullTryAcquireShared

在上述的簡單嘗試 tryAcquireShared 未能確定結果后，執行第三步 fullTryAcquireShared 自旋來不斷嘗試獲取讀鎖，直到成功獲取鎖返回1，或者滿足相應條件認定失敗返回-1。

1.其他線程持有寫鎖，失敗

2.當前線程讀的嘗試滿足堵塞條件表示當前線程排在其他線程后面，且當前線程沒有持有鎖即非重入的情況，失敗

3.其他情況則不斷自旋CAS，達到最大讀的數量會拋出異常，其他情況在成功后返回1。

final int fullTryAcquireShared(Thread current) { /* * This code is in part redundant with that in * tryAcquireShared but is simpler overall by not * complicating tryAcquireShared with interactions between * retries and lazily reading hold counts. */ HoldCounter rh = null; for (;;) {int c = getState();if (exclusiveCount(c) != 0) { // 存在其他線程持有寫鎖，返回-1 if (getExclusiveOwnerThread() != current)return -1; // else we hold the exclusive lock; blocking here // would cause deadlock. //沒有寫鎖，且該線程排在其他線程后面，應該被堵塞 //如果已經持有讀鎖，此次獲取是重入，可以執行else if 之后的操作； //否則，會被堵塞，返回-1。} else if (readerShouldBlock()) { // Make sure we’re not acquiring read lock reentrantly //檢查firstReader if (firstReader == current) {// assert firstReaderHoldCount > 0; } else {if (rh == null) { rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) { //執行到下一步rh是cached或者readHolds.get()，檢查rhrh = readHolds.get(); //在get時，如果不存在，會產生一個新的HoldCounter //記數為0表示不是重入鎖，會刪除讓其重新為nullif (rh.count == 0) readHolds.remove(); }} //返回失敗if (rh.count == 0) return -1; }} //達到最大值，不允許繼續增加if (sharedCount(c) == MAX_COUNT) throw new Error('Maximum lock count exceeded'); //和2.1.1中相似if (compareAndSetState(c, c + SHARED_UNIT)) { if (sharedCount(c) == 0) {firstReader = current;firstReaderHoldCount = 1; } else if (firstReader == current) {firstReaderHoldCount++; } else {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; // cache for release } return 1;} }}2.1.3 readerShouldBlock

該方法返回當前線程請求獲得讀鎖是否應該被堵塞，在公平鎖和非公平鎖中的實現不同

在公平鎖中，返回在排隊的隊列中當前線程之前是否存在其他線程，是的話返回 true，當前線程在隊列頭部或者隊列為空返回 false。

// FairSyncfinal boolean readerShouldBlock() { return hasQueuedPredecessors();}// AQSpublic final boolean hasQueuedPredecessors() { // The correctness of this depends on head being initialized // before tail and on head.next being accurate if the current // thread is first in queue. Node t = tail; // Read fields in reverse initialization order Node h = head; Node s; return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());}

在非公平鎖中，隊列中存在兩個節點，且第二個節點是獨占的寫節點，會返回 true，使得新來的讀線程堵塞。

這種方式只能在第二個節點是請求寫鎖的情況下返回 true，避免寫鎖的無限等待；如果寫鎖的請求節點在隊列的其他位置，返回 false，不影響新來的讀線程獲取讀鎖。

如果不按照這種方式處理，而按照隊列中的順序進行處理，則只要存在其他線程在讀，每次來一個新的線程請求讀鎖，總是成功，寫鎖會一直等待下去。

// NonfairSyncfinal boolean readerShouldBlock() { /* As a heuristic to avoid indefinite writer starvation, * block if the thread that momentarily appears to be head * of queue, if one exists, is a waiting writer. This is * only a probabilistic effect since a new reader will not * block if there is a waiting writer behind other enabled * readers that have not yet drained from the queue. */ return apparentlyFirstQueuedIsExclusive();}// AQSfinal boolean apparentlyFirstQueuedIsExclusive() { Node h, s; return (h = head) != null &&(s = h.next) != null &&!s.isShared() &&s.thread != null;}2.1.4 tryReadLock

和 fullTryAcquireShared 有相似之處，該方法總是直接去搶占鎖，直到其他線程獲取寫鎖返回失敗，或者當前當前線程獲取讀鎖返回成功。

//ReadLockpublic boolean tryLock() { return sync.tryReadLock();}//Syncfinal boolean tryReadLock() { Thread current = Thread.currentThread(); for (;;) {int c = getState();if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return false;int r = sharedCount(c);if (r == MAX_COUNT) throw new Error('Maximum lock count exceeded');if (compareAndSetState(c, c + SHARED_UNIT)) { if (r == 0) {firstReader = current;firstReaderHoldCount = 1; } else if (firstReader == current) {firstReaderHoldCount++; } else {HoldCounter rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current)) cachedHoldCounter = rh = readHolds.get();else if (rh.count == 0) readHolds.set(rh);rh.count++; } return true;} }}2.2 讀鎖的釋放

tryReleaseShared 在 if/else 中實現了通過 first/cached/readHolds 獲取相應的 HoldCounter，并修改其中的記數，記數為0則刪除；在 for 中，不斷自旋實現 CAS 修改狀態 c，如果修改后的狀態為0，表示讀寫鎖全部釋放，返回 true，否則是 false。

// ReadLockpublic void unlock() { sync.releaseShared(1);}// AQSpublic final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) {doReleaseShared();return true; } return false;}// Syncprotected final boolean tryReleaseShared(int unused) { Thread current = Thread.currentThread(); // 先檢查 firstReader是否是當前線程 if (firstReader == current) {// assert firstReaderHoldCount > 0;if (firstReaderHoldCount == 1) firstReader = null;else firstReaderHoldCount--; //否則，處理 cached/readHolds中的HoldCounter } else {HoldCounter rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current)) rh = readHolds.get();int count = rh.count;if (count <= 1) { readHolds.remove(); if (count <= 0)throw unmatchedUnlockException();}--rh.count; } //自旋修改 state for (;;) {int c = getState();int nextc = c - SHARED_UNIT;if (compareAndSetState(c, nextc)) // Releasing the read lock has no effect on readers, // but it may allow waiting writers to proceed if // both read and write locks are now free. //只有讀寫鎖均釋放干凈，才返回true return nextc == 0; }}三、寫鎖3.1 寫鎖的獲取

下面講解 tryAcquire 和 tryWriteLock，tryWriteLock 是一種非公平的獲取。

根據注釋，tryAcquire 分為三步

1.如果讀記數非0，或者寫記數非0且寫線程不是當前線程，失敗

2.寫鎖的獲取應該被堵塞或者CAS失敗，失敗

3.其他情況，寫重入和新來的寫線程，均成功

//WriteLockpublic void lock() { sync.acquire(1);}//AQSpublic final void acquire(int arg) { if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}//Syncprotected final boolean tryAcquire(int acquires) { /* * Walkthrough: * 1. If read count nonzero or write count nonzero * and owner is a different thread, fail. * 2. If count would saturate, fail. (This can only * happen if count is already nonzero.) * 3. Otherwise, this thread is eligible for lock if * it is either a reentrant acquire or * queue policy allows it. If so, update state * and set owner. */ Thread current = Thread.currentThread(); int c = getState(); int w = exclusiveCount(c); //c分為兩部分，寫和讀 if (c != 0) {// (Note: if c != 0 and w == 0 then shared count != 0) // c非0，w是0，則讀記數非0 || 獨占的寫線程不是當前線程 // 返回 falseif (w == 0 || current != getExclusiveOwnerThread()) return false;if (w + exclusiveCount(acquires) > MAX_COUNT) throw new Error('Maximum lock count exceeded');// Reentrant acquire // 重入的情況setState(c + acquires);return true; } // 寫應該被堵塞或者CAS失敗，返回false if (writerShouldBlock() ||!compareAndSetState(c, c + acquires))return false; // 非重入，在CAS成功后，設定獨占寫線程為當前線程，返回true setExclusiveOwnerThread(current); return true;}3.1.2 writerShouldBlock

在公平鎖中，檢查隊列前面是否有其他線程在排隊，在非公平鎖中，總是返回false，即總是不堵塞。

//FairSyncfinal boolean writerShouldBlock() { return hasQueuedPredecessors();}//NonfairSyncfinal boolean writerShouldBlock() { return false; // writers can always barge}3.1.3 tryWriteLock

和 tryAcquire 在非公平鎖的寫法基本一樣。

final boolean tryWriteLock() { Thread current = Thread.currentThread(); int c = getState(); if (c != 0) {int w = exclusiveCount(c);if (w == 0 || current != getExclusiveOwnerThread()) return false;if (w == MAX_COUNT) throw new Error('Maximum lock count exceeded'); } if (!compareAndSetState(c, c + 1))return false; setExclusiveOwnerThread(current); return true;}3.2 寫鎖的釋放

在 tryRelease 中，修改相應的狀態，如果修改后寫鎖記數為0，則返回 true。

//WriteLockpublic void unlock() { sync.release(1);}//AQSpublic final boolean release(int arg) { if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0) unparkSuccessor(h);return true; } return false;}//Syncprotected final boolean tryRelease(int releases) { // 首先檢查當前線程是否持有寫鎖 if (!isHeldExclusively())throw new IllegalMonitorStateException(); int nextc = getState() - releases; // 根據修改后的寫記數來確定free boolean free = exclusiveCount(nextc) == 0; // 此時，寫鎖完全釋放，設定寫獨占線程為null if (free)setExclusiveOwnerThread(null); setState(nextc); // 返回 free return free;}四、鎖降級

如果一個線程已經持有寫鎖，再去獲取讀鎖并釋放寫鎖，這個過程稱為鎖降級。

持有寫鎖的時候去獲取讀鎖，只有該持有寫鎖的線程能夠成功獲取讀鎖，然后再釋放寫鎖，保證此時當前線程是有讀鎖的；如果有寫鎖，先釋放寫鎖，再獲取讀鎖，可能暫時不能獲取讀鎖，會在隊列中排隊等待。

到此這篇關于Java基礎之ReentrantReadWriteLock源碼解析的文章就介紹到這了,更多相關Java ReentrantReadWriteLock源碼解析內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！