ReadWriteLock 和 ReentrantReadWriteLock介紹
ReadWriteLock，顧名思義，是讀寫鎖。它維護了一對相關的鎖 — — “讀取鎖”和“寫入鎖”，一個用于讀取操作，另一個用于寫入操作。
“讀取鎖”用于只讀操作，它是“共享鎖”，能同時被多個線程獲取。
“寫入鎖”用于寫入操作，它是“獨占鎖”，寫入鎖只能被一個線程鎖獲取。
注意：不能同時存在讀取鎖和寫入鎖！
ReadWriteLock是一個接口。ReentrantReadWriteLock是它的實現類，ReentrantReadWriteLock包括子類ReadLock和WriteLock。
ReadWriteLock 和 ReentrantReadWriteLock函數列表
ReadWriteLock函數列表
|
1
2
3
4
|
// 返回用于讀取操作的鎖。Lock readLock()// 返回用于寫入操作的鎖。Lock writeLock() |
ReentrantReadWriteLock函數列表
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
// 創建一個新的 ReentrantReadWriteLock，默認是采用“非公平策略”。ReentrantReadWriteLock()// 創建一個新的 ReentrantReadWriteLock，fair是“公平策略”。fair為true，意味著公平策略；否則，意味著非公平策略。ReentrantReadWriteLock(boolean fair)// 返回當前擁有寫入鎖的線程，如果沒有這樣的線程，則返回 null。protected Thread getOwner()// 返回一個 collection，它包含可能正在等待獲取讀取鎖的線程。protected Collection<Thread> getQueuedReaderThreads()// 返回一個 collection，它包含可能正在等待獲取讀取或寫入鎖的線程。protected Collection<Thread> getQueuedThreads()// 返回一個 collection，它包含可能正在等待獲取寫入鎖的線程。protected Collection<Thread> getQueuedWriterThreads()// 返回等待獲取讀取或寫入鎖的線程估計數目。int getQueueLength()// 查詢當前線程在此鎖上保持的重入讀取鎖數量。int getReadHoldCount()// 查詢為此鎖保持的讀取鎖數量。int getReadLockCount()// 返回一個 collection，它包含可能正在等待與寫入鎖相關的給定條件的那些線程。protected Collection<Thread> getWaitingThreads(Condition condition)// 返回正等待與寫入鎖相關的給定條件的線程估計數目。int getWaitQueueLength(Condition condition)// 查詢當前線程在此鎖上保持的重入寫入鎖數量。int getWriteHoldCount()// 查詢是否給定線程正在等待獲取讀取或寫入鎖。boolean hasQueuedThread(Thread thread)// 查詢是否所有的線程正在等待獲取讀取或寫入鎖。boolean hasQueuedThreads()// 查詢是否有些線程正在等待與寫入鎖有關的給定條件。boolean hasWaiters(Condition condition)// 如果此鎖將公平性設置為 ture，則返回 true。boolean isFair()// 查詢是否某個線程保持了寫入鎖。boolean isWriteLocked()// 查詢當前線程是否保持了寫入鎖。boolean isWriteLockedByCurrentThread()// 返回用于讀取操作的鎖。ReentrantReadWriteLock.ReadLock readLock()// 返回用于寫入操作的鎖。ReentrantReadWriteLock.WriteLock writeLock() |
ReentrantReadWriteLock數據結構
ReentrantReadWriteLock的UML類圖如下：
從中可以看出：
(01) ReentrantReadWriteLock實現了ReadWriteLock接口。ReadWriteLock是一個讀寫鎖的接口，提供了"獲取讀鎖的readLock()函數" 和 "獲取寫鎖的writeLock()函數"。
(02) ReentrantReadWriteLock中包含：sync對象，讀鎖readerLock和寫鎖writerLock。讀鎖ReadLock和寫鎖WriteLock都實現了Lock接口。讀鎖ReadLock和寫鎖WriteLock中也都分別包含了"Sync對象"，它們的Sync對象和ReentrantReadWriteLock的Sync對象 是一樣的，就是通過sync，讀鎖和寫鎖實現了對同一個對象的訪問。
(03) 和"ReentrantLock"一樣，sync是Sync類型；而且，Sync也是一個繼承于AQS的抽象類。Sync也包括"公平鎖"FairSync和"非公平鎖"NonfairSync。sync對象是"FairSync"和"NonfairSync"中的一個，默認是"NonfairSync"。
其中，共享鎖源碼相關的代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public static class ReadLock implements Lock, java.io.Serializable { private static final long serialVersionUID = -5992448646407690164L; // ReentrantReadWriteLock的AQS對象 private final Sync sync; protected ReadLock(ReentrantReadWriteLock lock) { sync = lock.sync; } // 獲取“共享鎖” public void lock() { sync.acquireShared(1); } // 如果線程是中斷狀態，則拋出一場，否則嘗試獲取共享鎖。 public void lockInterruptibly() throws InterruptedException { sync.acquireSharedInterruptibly(1); } // 嘗試獲取“共享鎖” public boolean tryLock() { return sync.tryReadLock(); } // 在指定時間內，嘗試獲取“共享鎖” public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); } // 釋放“共享鎖” public void unlock() { sync.releaseShared(1); } // 新建條件 public Condition newCondition() { throw new UnsupportedOperationException(); } public String toString() { int r = sync.getReadLockCount(); return super.toString() + "[Read locks = " + r + "]"; }} |
說明：
ReadLock中的sync是一個Sync對象，Sync繼承于AQS類，即Sync就是一個鎖。ReentrantReadWriteLock中也有一個Sync對象，而且ReadLock中的sync和ReentrantReadWriteLock中的sync是對應關系。即ReentrantReadWriteLock和ReadLock共享同一個AQS對象，共享同一把鎖。
ReentrantReadWriteLock中Sync的定義如下：
|
1
|
final Sync sync; |
下面，分別從“獲取共享鎖”和“釋放共享鎖”兩個方面對共享鎖進行說明。
獲取共享鎖
獲取共享鎖的思想(即lock函數的步驟)，是先通過tryAcquireShared()嘗試獲取共享鎖。嘗試成功的話，則直接返回；嘗試失敗的話，則通過doAcquireShared()不斷的循環并嘗試獲取鎖，若有需要，則阻塞等待。doAcquireShared()在循環中每次嘗試獲取鎖時，都是通過tryAcquireShared()來進行嘗試的。下面看看“獲取共享鎖”的詳細流程。
1. lock()
lock()在ReadLock中，源碼如下：
|
1
2
3
|
public void lock() { sync.acquireShared(1);} |
2. acquireShared()
Sync繼承于AQS，acquireShared()定義在AQS中。源碼如下：
|
1
2
3
4
|
public final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0) doAcquireShared(arg);} |
說明：acquireShared()首先會通過tryAcquireShared()來嘗試獲取鎖。
嘗試成功的話，則不再做任何動作(因為已經成功獲取到鎖了)。
嘗試失敗的話，則通過doAcquireShared()來獲取鎖。doAcquireShared()會獲取到鎖了才返回。
3. tryAcquireShared()
tryAcquireShared()定義在ReentrantReadWriteLock.java的Sync中，源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
protected final int tryAcquireShared(int unused) { Thread current = Thread.currentThread(); // 獲取“鎖”的狀態 int c = getState(); // 如果“鎖”是“互斥鎖”，并且獲取鎖的線程不是current線程；則返回-1。 if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return -1; // 獲取“讀取鎖”的共享計數 int r = sharedCount(c); // 如果“不需要阻塞等待”，并且“讀取鎖”的共享計數小于MAX_COUNT； // 則通過CAS函數更新“鎖的狀態”，將“讀取鎖”的共享計數+1。 if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) { // 第1次獲取“讀取鎖”。 if (r == 0) { firstReader = current; firstReaderHoldCount = 1; // 如果想要獲取鎖的線程(current)是第1個獲取鎖(firstReader)的線程 } else if (firstReader == current) { firstReaderHoldCount++; } else { // HoldCounter是用來統計該線程獲取“讀取鎖”的次數。 HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != current.getId()) cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); // 將該線程獲取“讀取鎖”的次數+1。 rh.count++; } return 1; } return fullTryAcquireShared(current);} |
說明：tryAcquireShared()的作用是嘗試獲取“共享鎖”。
如果在嘗試獲取鎖時，“不需要阻塞等待”并且“讀取鎖的共享計數小于MAX_COUNT”，則直接通過CAS函數更新“讀取鎖的共享計數”，以及將“當前線程獲取讀取鎖的次數+1”。否則，通過fullTryAcquireShared()獲取讀取鎖。
4. fullTryAcquireShared()
fullTryAcquireShared()在ReentrantReadWriteLock中定義，源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
final int fullTryAcquireShared(Thread current) { HoldCounter rh = null; for (;;) { // 獲取“鎖”的狀態 int c = getState(); // 如果“鎖”是“互斥鎖”，并且獲取鎖的線程不是current線程；則返回-1。 if (exclusiveCount(c) != 0) { if (getExclusiveOwnerThread() != current) return -1; // 如果“需要阻塞等待”。 // (01) 當“需要阻塞等待”的線程是第1個獲取鎖的線程的話，則繼續往下執行。 // (02) 當“需要阻塞等待”的線程獲取鎖的次數=0時，則返回-1。 } else if (readerShouldBlock()) { // 如果想要獲取鎖的線程(current)是第1個獲取鎖(firstReader)的線程 if (firstReader == current) { } else { if (rh == null) { rh = cachedHoldCounter; if (rh == null || rh.tid != current.getId()) { rh = readHolds.get(); if (rh.count == 0) readHolds.remove(); } } // 如果當前線程獲取鎖的計數=0,則返回-1。 if (rh.count == 0) return -1; } } // 如果“不需要阻塞等待”，則獲取“讀取鎖”的共享統計數； // 如果共享統計數超過MAX_COUNT，則拋出異常。 if (sharedCount(c) == MAX_COUNT) throw new Error("Maximum lock count exceeded"); // 將線程獲取“讀取鎖”的次數+1。 if (compareAndSetState(c, c + SHARED_UNIT)) { // 如果是第1次獲取“讀取鎖”，則更新firstReader和firstReaderHoldCount。 if (sharedCount(c) == 0) { firstReader = current; firstReaderHoldCount = 1; // 如果想要獲取鎖的線程(current)是第1個獲取鎖(firstReader)的線程， // 則將firstReaderHoldCount+1。 } else if (firstReader == current) { firstReaderHoldCount++; } else { if (rh == null) rh = cachedHoldCounter; if (rh == null || rh.tid != current.getId()) rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); // 更新線程的獲取“讀取鎖”的共享計數 rh.count++; cachedHoldCounter = rh; // cache for release } return 1; } }} |
說明：fullTryAcquireShared()會根據“是否需要阻塞等待”，“讀取鎖的共享計數是否超過限制”等等進行處理。如果不需要阻塞等待，并且鎖的共享計數沒有超過限制，則通過CAS嘗試獲取鎖，并返回1。
5. doAcquireShared()
doAcquireShared()定義在AQS函數中，源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
private void doAcquireShared(int arg) { // addWaiter(Node.SHARED)的作用是，創建“當前線程”對應的節點，并將該線程添加到CLH隊列中。 final Node node = addWaiter(Node.SHARED); boolean failed = true; try { boolean interrupted = false; for (;;) { // 獲取“node”的前一節點 final Node p = node.predecessor(); // 如果“當前線程”是CLH隊列的表頭，則嘗試獲取共享鎖。 if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC if (interrupted) selfInterrupt(); failed = false; return; } } // 如果“當前線程”不是CLH隊列的表頭，則通過shouldParkAfterFailedAcquire()判斷是否需要等待， // 需要的話，則通過parkAndCheckInterrupt()進行阻塞等待。若阻塞等待過程中，線程被中斷過，則設置interrupted為true。 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); }} |
說明：doAcquireShared()的作用是獲取共享鎖。
它會首先創建線程對應的CLH隊列的節點，然后將該節點添加到CLH隊列中。CLH隊列是管理獲取鎖的等待線程的隊列。
如果“當前線程”是CLH隊列的表頭，則嘗試獲取共享鎖；否則，則需要通過shouldParkAfterFailedAcquire()判斷是否阻塞等待，需要的話，則通過parkAndCheckInterrupt()進行阻塞等待。
doAcquireShared()會通過for循環，不斷的進行上面的操作；目的就是獲取共享鎖。需要注意的是：doAcquireShared()在每一次嘗試獲取鎖時，是通過tryAcquireShared()來執行的！
釋放共享鎖
釋放共享鎖的思想，是先通過tryReleaseShared()嘗試釋放共享鎖。嘗試成功的話，則通過doReleaseShared()喚醒“其他等待獲取共享鎖的線程”，并返回true；否則的話，返回flase。
1. unlock()
|
1
2
3
|
public void unlock() { sync.releaseShared(1);} |
說明：該函數實際上調用releaseShared(1)釋放共享鎖。
2. releaseShared()
releaseShared()在AQS中實現，源碼如下：
|
1
2
3
4
5
6
7
|
public final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) { doReleaseShared(); return true; } return false;} |
說明：releaseShared()的目的是讓當前線程釋放它所持有的共享鎖。
它首先會通過tryReleaseShared()去嘗試釋放共享鎖。嘗試成功，則直接返回；嘗試失敗，則通過doReleaseShared()去釋放共享鎖。
3. tryReleaseShared()
tryReleaseShared()定義在ReentrantReadWriteLock中，源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
protected final boolean tryReleaseShared(int unused) { // 獲取當前線程，即釋放共享鎖的線程。 Thread current = Thread.currentThread(); // 如果想要釋放鎖的線程(current)是第1個獲取鎖(firstReader)的線程， // 并且“第1個獲取鎖的線程獲取鎖的次數”=1，則設置firstReader為null； // 否則，將“第1個獲取鎖的線程的獲取次數”-1。 if (firstReader == current) { // assert firstReaderHoldCount > 0; if (firstReaderHoldCount == 1) firstReader = null; else firstReaderHoldCount--; // 獲取rh對象，并更新“當前線程獲取鎖的信息”。 } else { HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != current.getId()) rh = readHolds.get(); int count = rh.count; if (count <= 1) { readHolds.remove(); if (count <= 0) throw unmatchedUnlockException(); } --rh.count; } for (;;) { // 獲取鎖的狀態 int c = getState(); // 將鎖的獲取次數-1。 int nextc = c - SHARED_UNIT; // 通過CAS更新鎖的狀態。 if (compareAndSetState(c, nextc)) return nextc == 0; }} |
說明：tryReleaseShared()的作用是嘗試釋放共享鎖。
4. doReleaseShared()
doReleaseShared()定義在AQS中，源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
private void doReleaseShared() { for (;;) { // 獲取CLH隊列的頭節點 Node h = head; // 如果頭節點不為null，并且頭節點不等于tail節點。 if (h != null && h != tail) { // 獲取頭節點對應的線程的狀態 int ws = h.waitStatus; // 如果頭節點對應的線程是SIGNAL狀態，則意味著“頭節點的下一個節點所對應的線程”需要被unpark喚醒。 if (ws == Node.SIGNAL) { // 設置“頭節點對應的線程狀態”為空狀態。失敗的話，則繼續循環。 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) continue; // 喚醒“頭節點的下一個節點所對應的線程”。 unparkSuccessor(h); } // 如果頭節點對應的線程是空狀態，則設置“文件點對應的線程所擁有的共享鎖”為其它線程獲取鎖的空狀態。 else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) continue; // loop on failed CAS } // 如果頭節點發生變化，則繼續循環。否則，退出循環。 if (h == head) // loop if head changed break; }} |
說明：doReleaseShared()會釋放“共享鎖”。它會從前往后的遍歷CLH隊列，依次“喚醒”然后“執行”隊列中每個節點對應的線程；最終的目的是讓這些線程釋放它們所持有的鎖。
公平共享鎖和非公平共享鎖
和互斥鎖ReentrantLock一樣，ReadLock也分為公平鎖和非公平鎖。
公平鎖和非公平鎖的區別，體現在判斷是否需要阻塞的函數readerShouldBlock()是不同的。
公平鎖的readerShouldBlock()的源碼如下：
|
1
2
3
|
final boolean readerShouldBlock() { return hasQueuedPredecessors();} |
在公平共享鎖中，如果在當前線程的前面有其他線程在等待獲取共享鎖，則返回true；否則，返回false。
非公平鎖的readerShouldBlock()的源碼如下：
|
1
2
3
|
final boolean readerShouldBlock() { return apparentlyFirstQueuedIsExclusive();} |
在非公平共享鎖中，它會無視當前線程的前面是否有其他線程在等待獲取共享鎖。只要該非公平共享鎖對應的線程不為null，則返回true。
ReentrantReadWriteLock示例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockTest1 { public static void main(String[] args) { // 創建賬戶 MyCount myCount = new MyCount("4238920615242830", 10000); // 創建用戶，并指定賬戶 User user = new User("Tommy", myCount); // 分別啟動3個“讀取賬戶金錢”的線程 和 3個“設置賬戶金錢”的線程 for (int i=0; i<3; i++) { user.getCash(); user.setCash((i+1)*1000); } } } class User { private String name; //用戶名 private MyCount myCount; //所要操作的賬戶 private ReadWriteLock myLock; //執行操作所需的鎖對象 User(String name, MyCount myCount) { this.name = name; this.myCount = myCount; this.myLock = new ReentrantReadWriteLock(); } public void getCash() { new Thread() { public void run() { myLock.readLock().lock(); try { System.out.println(Thread.currentThread().getName() +" getCash start"); myCount.getCash(); Thread.sleep(1); System.out.println(Thread.currentThread().getName() +" getCash end"); } catch (InterruptedException e) { } finally { myLock.readLock().unlock(); } } }.start(); } public void setCash(final int cash) { new Thread() { public void run() { myLock.writeLock().lock(); try { System.out.println(Thread.currentThread().getName() +" setCash start"); myCount.setCash(cash); Thread.sleep(1); System.out.println(Thread.currentThread().getName() +" setCash end"); } catch (InterruptedException e) { } finally { myLock.writeLock().unlock(); } } }.start(); }}class MyCount { private String id; //賬號 private int cash; //賬戶余額 MyCount(String id, int cash) { this.id = id; this.cash = cash; } public String getId() { return id; } public void setId(String id) { this.id = id; } public int getCash() { System.out.println(Thread.currentThread().getName() +" getCash cash="+ cash); return cash; } public void setCash(int cash) { System.out.println(Thread.currentThread().getName() +" setCash cash="+ cash); this.cash = cash; } } |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
Thread-0 getCash startThread-2 getCash startThread-0 getCash cash=10000Thread-2 getCash cash=10000Thread-0 getCash endThread-2 getCash endThread-1 setCash startThread-1 setCash cash=1000Thread-1 setCash endThread-3 setCash startThread-3 setCash cash=2000Thread-3 setCash endThread-4 getCash startThread-4 getCash cash=2000Thread-4 getCash endThread-5 setCash startThread-5 setCash cash=3000Thread-5 setCash end |
結果說明：
(01) 觀察Thread0和Thread-2的運行結果，我們發現，Thread-0啟動并獲取到“讀取鎖”，在它還沒運行完畢的時候，Thread-2也啟動了并且也成功獲取到“讀取鎖”。
因此，“讀取鎖”支持被多個線程同時獲取。
(02) 觀察Thread-1,Thread-3,Thread-5這三個“寫入鎖”的線程。只要“寫入鎖”被某線程獲取，則該線程運行完畢了，才釋放該鎖。
因此，“寫入鎖”不支持被多個線程同時獲取。
