ReentrantReadWriteLock包含两把锁,一是读锁ReadLock, 此乃共享锁, 一是写锁WriteLock, 此乃排它锁. 这两把锁都是基于AQS来实现的.
下面通过源码来看看ReentrantReadWriteLock是如何做到读读共享,读写互斥的.
1. 测试代码
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ShareLockTest {
public static void main(String[] args) {
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
CyclicBarrier cyclicBarrier = new CyclicBarrier(50);
for (int i = 1; i <= 50; i++) {
int finalI = i;
new Thread(() -> {
try {
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
if (finalI % 2 == 0) {
System.out.println(Thread.currentThread().getName() + "开始抢写锁");
writeLock.lock();
} else {
System.out.println(Thread.currentThread().getName() + "开始抢读锁");
readLock.lock();
}
try {
System.out.println(Thread.currentThread().getName() + "抢读锁成功");
Thread.currentThread().sleep(1000);
System.out.println(Thread.currentThread().getName() + "释放读锁");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (finalI % 2 == 0) {
writeLock.unlock();
} else {
readLock.unlock();
}
}
}, "线程" + i).start();
}
System.out.println("main over");
}
}
2. 获取读锁资源
读锁资源的获取通过下面这段代码实现
protected final int tryAcquireShared(int unused) {
// 1. 如果读锁被其它线程持有,失败
// 当前抢锁的线程
Thread current = Thread.currentThread();
// AQS四大属性中的state值
int c = getState();
// 如果持有写锁的线程数量不等于0 且 当前线程不是AQS中的保存的写锁线程 (忽略重入情况)
if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) // 简单讲就是当前线程不是持有写锁的线程就返回-1
return -1; // 获取读锁失败
// 拥有读锁的线程数量
int r = sharedCount(c);
if (!readerShouldBlock() // 不需要排队
&& r < MAX_COUNT // 拥有读锁的线程数量 小于65535
&& compareAndSetState(c, c + SHARED_UNIT)) { // 通过cas将AQS中state值由c修改成c+65536
if (r == 0) {// 如果还没有线程持有读锁
firstReader = current; // 将当前线程赋值给firstReader这个变量,其实就是标识一下
firstReaderHoldCount = 1; // 读锁持有量记为1,以便于这个线程再次获取读锁时进行累加
} else if (firstReader == current) { //如果当前线程等于firstReader,将firstReaderHoldCount加1
firstReaderHoldCount++;
} else { // 如果是其它的线程来获取读锁
// 与上面原理一样,也是一个计数器,来计录每个线程获取读锁的次数(底层使用了一个ThreadLocal)
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 1; // 获取读锁成功
}
// 没看懂, 似乎是为了抓捕漏网之鱼
return fullTryAcquireShared(current);
}
以上代码不难, 就是通过 tryAcquireShared获取读锁资源 ,如果获取读锁失败, 就会执行 doAcquireShared 方法. 这个方法有两个功能, 首次是将当前线程封装成一个Node节点(注意该Node是SHARED模式),然后通过addWaiter方法将其添加到CLH链表的尾部. 再次就是将其park.
3. 获取写锁资源
下面这段代码就是尝试获取写锁的过程
protected final boolean tryAcquire(int acquires) {
// 当前线程
Thread current = Thread.currentThread();
// AQS四大属性的state, 只有在即无读锁也无写锁的情况,才等于0
int c = getState();
// 写锁的数量
int w = exclusiveCount(c);
if (c != 0) { // 表示已经有线程持有锁(可能是读锁,也可能是写锁)
// (Note: if c != 0 and w == 0 then shared count != 0)
if (w == 0 || current != getExclusiveOwnerThread()) // 无线程持有写锁,或者是持有写锁的线程不是当前线程,返回false
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// 重入, 持有写锁的线程再次获取锁,对state值进行更新
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||!compareAndSetState(c, c + acquires)) // NonfairSync 默认就是false
return false;
// 当前线程获取到锁
setExclusiveOwnerThread(current);
return true;
}
就是通过上面这段代码来进行写锁获取,可以看到当前线程能否获取到写锁资源, 最终还是通过AQS中exclusiveOwnerThread与当前线程进行比较.
(1) c = 0 , w= 0 时 , 说明还没有线程持有锁资源(读锁和写锁), 这时当前线程获取写锁肯定成功(应该只有第一次获取写锁才会走到下面的逻辑)
compareAndSetState(c, c + acquires) //将AQS中state设置为1
setExclusiveOwnerThread(current); //将AQS中exclusiveOwnerThread设置为当前线程
(2) c != 0 , w =0时, 先判断写锁数量是否等于0,.如果等于0再判断 exclusiveOwnerThread 是否是当前线程,如果不是,返回false,获取写锁资源失败. 如果是, 表示当前线程再次获取写锁资源了(重入锁的情况), 这时会对AQS对象的state属性值加1, 同时返回true, 获取写锁成功.
总之, tryAcquire()方法就是尝试获取写锁资源, 如果获取成功,一切好说. 如果获取失败, 就会通过 addWaiter方法将当前线程封装成一个Node节点(注意该节点是EXCLUSIVE模式),放到CLH链表中,然后再通过acquireQueued方法将当前线程进行park.(具体过程可参考AQS源码分析笔记 )
4. 读锁释放, 写锁唤醒
咱们通过debug来模拟这样一种情况 . 1号线程和11号线程持有读锁, 10号线程,20号线程获取写锁没成功, 被挂起了.
现在1号线程释放读锁资源, 看看会发生什么情况....
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} 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;
}
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
tryReleaseShared方法很简单,唯一需要注意的就是标红部分,只有当最终return的结果是true时,才会进入到 doReleaseShared()方法中, 看下源码
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h); // 唤醒线程
}
else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
通过debug, 不难发现, 读锁资源被1号线程和11号线程持有,我先释放1号线程的读锁资源,结果读锁资源并没有释放成功, 我再去11号线程的读锁资源, 结果释放成功. 然后进入到doReleaseShared()方法中,这个方法主要就是去唤醒CLH链表中线程.
5. 写锁释放,唤醒写锁
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
这段代码在讲AQS中也提到过, 如果锁资源释放成功,会通过unparkSuccessor方法唤醒CLH链表中下一个节点的线程, 这时不再多说了.
6. 写锁释放,唤醒读锁
这种情况有点特别, 先是通过释放写锁的线程去唤醒CLH链表中head节点next节点指向的读锁线程, 然后再通过这个读锁线程递归唤醒所有读锁线程
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread); // 唤醒CLH链表中第一个读锁线程
}
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
注意标红部分,读锁线程被唤醒之后,for循环就活了,然后就会调用 setHeadAndPropagate(node, r)---> doReleaseShared() ----> unparkSuccessor(h),
如果最后这个unparkSuccessor(h)方法中,h节点的下一个节点是读锁线程,那么又会触发一次 setHeadAndPropagate(node, r)---> doReleaseShared() ----> unparkSuccessor(h)调用链,直到将所有读锁线程都唤醒.
7. 总结
(1) ReentrantReadWriteLock是在AQS的基础上实现读,写锁分离的过程.
(2) 将state这个属性值 拆分为高低位,来实现读,写锁控制 (有点懵, 位运算,与运算可读性差...)
(3) 读,写锁线程的Node节点仍然是放在CLH链表中的..
(4) 读锁线程唤醒可一次性唤醒多个, 写锁线程一次只能唤醒 一个