java 共享锁_Java锁--共享锁和ReentrantReadWriteLock
ReadWriteLock 和 ReentrantReadWriteLock介紹
ReadWriteLock，顧名思義，是讀寫鎖。它維護了一對相關的鎖 — — “讀取鎖”和“寫入鎖”，一個用于讀取操作，另一個用于寫入操作。
“讀取鎖”用于只讀操作，它是“共享鎖”，能同時被多個線程獲取。
“寫入鎖”用于寫入操作，它是“獨占鎖”，寫入鎖只能被一個線程鎖獲取。
注意：不能同時存在讀取鎖和寫入鎖！
ReadWriteLock是一個接口。ReentrantReadWriteLock是它的實現類，ReentrantReadWriteLock包括子類ReadLock和WriteLock。
ReadWriteLock 和 ReentrantReadWriteLock函數列表
ReadWriteLock函數列表
// 返回用于讀取操作的鎖。
Lock readLock()
// 返回用于寫入操作的鎖。
Lock writeLock()
ReentrantReadWriteLock函數列表
// 創建一個新的 ReentrantReadWriteLock，默認是采用“非公平策略”。
ReentrantReadWriteLock()
// 創建一個新的 ReentrantReadWriteLock，fair是“公平策略”。fair為true，意味著公平策略；否則，意味著非公平策略。
ReentrantReadWriteLock(boolean fair)
// 返回當前擁有寫入鎖的線程，如果沒有這樣的線程，則返回 null。
protected Thread getOwner()
// 返回一個 collection，它包含可能正在等待獲取讀取鎖的線程。
protected Collection getQueuedReaderThreads()
// 返回一個 collection，它包含可能正在等待獲取讀取或寫入鎖的線程。
protected Collection getQueuedThreads()
// 返回一個 collection，它包含可能正在等待獲取寫入鎖的線程。
protected Collection getQueuedWriterThreads()
// 返回等待獲取讀取或寫入鎖的線程估計數目。
int getQueueLength()
// 查詢當前線程在此鎖上保持的重入讀取鎖數量。
int getReadHoldCount()
// 查詢為此鎖保持的讀取鎖數量。
int getReadLockCount()
// 返回一個 collection，它包含可能正在等待與寫入鎖相關的給定條件的那些線程。
protected Collection 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"。
參考代碼(基于JDK1.7.0_40)
ReentrantReadWriteLock的完整源碼
?View Code
AQS的完整源碼
?View Code
其中，共享鎖源碼相關的代碼如下：
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的定義如下：
final Sync sync;
下面，分別從“獲取共享鎖”和“釋放共享鎖”兩個方面對共享鎖進行說明。
獲取共享鎖
獲取共享鎖的思想(即lock函數的步驟)，是先通過tryAcquireShared()嘗試獲取共享鎖。嘗試成功的話，則直接返回；嘗試失敗的話，則通過doAcquireShared()不斷的循環并嘗試獲取鎖，若有需要，則阻塞等待。doAcquireShared()在循環中每次嘗試獲取鎖時，都是通過tryAcquireShared()來進行嘗試的。下面看看“獲取共享鎖”的詳細流程。
1. lock()
lock()在ReadLock中，源碼如下：
public void lock() {
sync.acquireShared(1);
}
2. acquireShared()
Sync繼承于AQS，acquireShared()定義在AQS中。源碼如下：
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
說明：acquireShared()首先會通過tryAcquireShared()來嘗試獲取鎖。
嘗試成功的話，則不再做任何動作(因為已經成功獲取到鎖了)。
嘗試失敗的話，則通過doAcquireShared()來獲取鎖。doAcquireShared()會獲取到鎖了才返回。
3. tryAcquireShared()
tryAcquireShared()定義在ReentrantReadWriteLock.java的Sync中，源碼如下：
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中定義，源碼如下：
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函數中，源碼如下：
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()來執行的！
shouldParkAfterFailedAcquire(), parkAndCheckInterrupt()等函數已經在“Java多線程系列--“JUC鎖”03之 公平鎖(一)?”中詳細介紹過，這里就不再重復說明了。
釋放共享鎖
釋放共享鎖的思想，是先通過tryReleaseShared()嘗試釋放共享鎖。嘗試成功的話，則通過doReleaseShared()喚醒“其他等待獲取共享鎖的線程”，并返回true；否則的話，返回flase。
1. unlock()
public void unlock() {
sync.releaseShared(1);
}
說明：該函數實際上調用releaseShared(1)釋放共享鎖。
2. releaseShared()
releaseShared()在AQS中實現，源碼如下：
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
說明：releaseShared()的目的是讓當前線程釋放它所持有的共享鎖。
它首先會通過tryReleaseShared()去嘗試釋放共享鎖。嘗試成功，則直接返回；嘗試失敗，則通過doReleaseShared()去釋放共享鎖。
3. tryReleaseShared()
tryReleaseShared()定義在ReentrantReadWriteLock中，源碼如下：
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中，源碼如下：
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()的源碼如下：
final boolean readerShouldBlock() {
return hasQueuedPredecessors();
}
在公平共享鎖中，如果在當前線程的前面有其他線程在等待獲取共享鎖，則返回true；否則，返回false。
非公平鎖的readerShouldBlock()的源碼如下：
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
}
在非公平共享鎖中，它會無視當前線程的前面是否有其他線程在等待獲取共享鎖。只要該非公平共享鎖對應的線程不為null，則返回true。
ReentrantReadWriteLock示例
1 import java.util.concurrent.locks.ReadWriteLock;
2 import java.util.concurrent.locks.ReentrantReadWriteLock;
3
4 public class ReadWriteLockTest1 {
5
6 public static void main(String[] args) {
7 // 創建賬戶
8 MyCount myCount = new MyCount("4238920615242830", 10000);
9 // 創建用戶，并指定賬戶
10 User user = new User("Tommy", myCount);
11
12 // 分別啟動3個“讀取賬戶金錢”的線程 和 3個“設置賬戶金錢”的線程
13 for (int i=0; i<3; i++) {
14 user.getCash();
15 user.setCash((i+1)*1000);
16 }
17 }
18 }
19
20 class User {
21 private String name; //用戶名
22 private MyCount myCount; //所要操作的賬戶
23 private ReadWriteLock myLock; //執行操作所需的鎖對象
24
25 User(String name, MyCount myCount) {
26 this.name = name;
27 this.myCount = myCount;
28 this.myLock = new ReentrantReadWriteLock();
29 }
30
31 public void getCash() {
32 new Thread() {
33 public void run() {
34 myLock.readLock().lock();
35 try {
36 System.out.println(Thread.currentThread().getName() +" getCash start");
37 myCount.getCash();
38 Thread.sleep(1);
39 System.out.println(Thread.currentThread().getName() +" getCash end");
40 } catch (InterruptedException e) {
41 } finally {
42 myLock.readLock().unlock();
43 }
44 }
45 }.start();
46 }
47
48 public void setCash(final int cash) {
49 new Thread() {
50 public void run() {
51 myLock.writeLock().lock();
52 try {
53 System.out.println(Thread.currentThread().getName() +" setCash start");
54 myCount.setCash(cash);
55 Thread.sleep(1);
56 System.out.println(Thread.currentThread().getName() +" setCash end");
57 } catch (InterruptedException e) {
58 } finally {
59 myLock.writeLock().unlock();
60 }
61 }
62 }.start();
63 }
64 }
65
66 class MyCount {
67 private String id; //賬號
68 private int cash; //賬戶余額
69
70 MyCount(String id, int cash) {
71 this.id = id;
72 this.cash = cash;
73 }
74
75 public String getId() {
76 return id;
77 }
78
79 public void setId(String id) {
80 this.id = id;
81 }
82
83 public int getCash() {
84 System.out.println(Thread.currentThread().getName() +" getCash cash="+ cash);
85 return cash;
86 }
87
88 public void setCash(int cash) {
89 System.out.println(Thread.currentThread().getName() +" setCash cash="+ cash);
90 this.cash = cash;
91 }
92 }
運行結果：
Thread-0 getCash start
Thread-2 getCash start
Thread-0 getCash cash=10000
Thread-2 getCash cash=10000
Thread-0 getCash end
Thread-2 getCash end
Thread-1 setCash start
Thread-1 setCash cash=1000
Thread-1 setCash end
Thread-3 setCash start
Thread-3 setCash cash=2000
Thread-3 setCash end
Thread-4 getCash start
Thread-4 getCash cash=2000
Thread-4 getCash end
Thread-5 setCash start
Thread-5 setCash cash=3000
Thread-5 setCash end
結果說明：
(01) 觀察Thread0和Thread-2的運行結果，我們發現，Thread-0啟動并獲取到“讀取鎖”，在它還沒運行完畢的時候，Thread-2也啟動了并且也成功獲取到“讀取鎖”。
因此，“讀取鎖”支持被多個線程同時獲取。
(02) 觀察Thread-1,Thread-3,Thread-5這三個“寫入鎖”的線程。只要“寫入鎖”被某線程獲取，則該線程運行完畢了，才釋放該鎖。
因此，“寫入鎖”不支持被多個線程同時獲取。
總結
以上是生活随笔為你收集整理的java 共享锁_Java锁--共享锁和ReentrantReadWriteLock的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： ps合并图层快捷键(ps向下合并图层快捷
- 下一篇： java字节码运行原理_JVM 内部原理