一、概述
上一篇源码解读java 并发包 AQS（阳哥讲解整理）我通过ReentrantLock对AQS的独占模式非公平锁进行了讲解，本篇文章，我们将已CountDownLatch讲解下共享模式下的AQS实现
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。
二、CountDownLatch框架
- await();//阻塞当前线程，将当前线程加入阻塞队列。
- await(long timeout, TimeUnit
unit);//在timeout的时间之内阻塞当前线程,时间一过则当前线程可以执行
- countDown();//对计数器进行递减1操作，当计数器递减至0时，当前线程会去唤醒阻塞队列里的所有线程。
三、源码讲解
我们来模拟一个案例，3个线程A,B,C去执行任务，A任务必须在BC两个任务执行完再执行，定义一个CountDownLatch，计数器为2
CountDownLatch countDownLatch = new CountDownLatch(2);
3个线程执行任务
new Thread(()->{
try {
countDownLatch.await();
System.out.println("A thread come in ---------");
}catch (Exception e){
}
},"A").start();
new Thread(()->{
try {
System.out.println("B thread come in ---------");
TimeUnit.MINUTES.sleep(5);
countDownLatch.countDown();
}catch (Exception e){
}
},"B").start();
new Thread(()->{
try {
System.out.println("C thread come in ---------");
TimeUnit.MINUTES.sleep(5);
countDownLatch.countDown();
}catch (Exception e){
}
},"C").start();
B,C线程sleep 5分钟后countDown，计数器为0后A在执行
进入await()方法
CountDownLatch.java
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
AbstractQueuedSynchronizer.java
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)//获取锁
doAcquireSharedInterruptibly(arg);
}
先进入tryAcquireShared(arg)方法尝试获取资源转到CountDownLatch中的实现方法
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
判断状态是否为0，定义的初始值为2，返回-1，进入doAcquireSharedInterruptibly(arg);
AbstractQueuedSynchronizer.java
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);//添加一个共享节点到队列尾部
boolean failed = true;//等待过程中是否被中断过的标志
try {
for (;;) {
final Node p = node.predecessor();//前驱
if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
int r = tryAcquireShared(arg);//再次尝试获取资源
if (r >= 0) {
setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
addWaiter(Node.SHARED);//添加一个共享节点到队列尾部在前一篇文章已经讲解，过程一直，不在赘述，前驱节点为head,再次尝试获取资源，明显失败，r<0走下面的if判断
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
shouldParkAfterFailedAcquire(p, node)同理也讲过，循环设置哨兵head节点waitStatus为SIGNEL(-1)返回true
进入parkAndCheckInterrupt()方法，挂机A线程
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
此时B,C线程进入执行 countDown();
AQS.java
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
进入判断 tryReleaseShared(arg)方法
CountDownLatch.java
protected boolean tryReleaseShared(int releases) {
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
B 获取状态c=2,nextc =2-1=1,设置状态为1，返回false
C 获取状态c=1,nextc =1-1=0,设置状态为0，返回true
此时进入doReleaseShared();方法
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;//哨兵节点状态为-1
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//哨兵节点状态设置为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;
}
}
把哨兵节点状态设置为0，唤醒之前的A线程
A线程被唤醒继续执行方法
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);//添加一个共享节点到队列尾部
boolean failed = true;//等待过程中是否被中断过的标志
try {
for (;;) {
final Node p = node.predecessor();//前驱
if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
int r = tryAcquireShared(arg);//再次尝试获取资源
if (r >= 0) {
setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
得到前驱为head,再次尝试获取资源成功，r>0,执行
setHeadAndPropagate(node, r);方法
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // 拿到head哨兵节点
setHead(node);//把哨兵节点置为刚才的A节点
//propagate>0
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;//找到后继几点
if (s == null || s.isShared())//不为空或者是共享节点
doReleaseShared();//陆续唤醒
}
}
此方法在setHead()的基础上多了一步，就是自己苏醒的同时，如果条件符合（比如还有剩余资源），还会去唤醒后继结点，共享模式
移除原来的哨兵节点，设置当前的节点为哨兵节点，propagate为1继续执行获取后继，不断唤醒所有等待中的共享节点线程
至此CountDownLatch源码分析完毕
总结
CountDownLatch使用的AQS的共享模式实现主要就是继承实现
tryAcquireShared(int)，tryReleaseShared(int)这两方法
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)//获取锁
doAcquireSharedInterruptibly(arg);
}
- tryAcquireShared(arg)
- doAcquireSharedInterruptibly(arg)
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
- tryReleaseShared(arg)
- doReleaseShared()
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
