说明
建议先了解ReentrantLock源码,这里有些地方在上期介绍ReentrantLock源码时已经说过了,这里就不过多赘述了,见谅。
作用
CountDownLatch 主要是记录某些线程满足某个条件时,去唤醒主线程(被await的线程)。下面看一个demo
DEMO
package com.skindow.sql;
import java.util.concurrent.CountDownLatch;
/**
* @ Author :syc.
* @ Date :Created in 09:32 2021/3/12
* @ Description:
* @ Modified By:
* @ Version:
*/
public class CountDownTest {
public static final Integer count = 10;
public static final CountDownLatch COUNT_DOWN_LATCH = new CountDownLatch(count);
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
myThread myThread = new myThread();
myThread.setName("test_" + i);
myThread.start();
}
try {
COUNT_DOWN_LATCH.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count + "个线程全部执行完毕");
}
private static class myThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " RUNNING");
COUNT_DOWN_LATCH.countDown();
System.out.println(Thread.currentThread().getName() + " END");
}
}
}
打印如下:
test_0 RUNNING
test_2 RUNNING
test_0 END
test_1 RUNNING
test_3 RUNNING
test_3 END
test_2 END
test_4 RUNNING
test_4 END
test_1 END
test_6 RUNNING
test_5 RUNNING
test_6 END
test_5 END
test_7 RUNNING
test_8 RUNNING
test_8 END
test_9 RUNNING
test_7 END
test_9 END
10个线程全部执行完毕
结构图
构造函数
public CountDownLatch(int count) {
//初始化一个同步队列
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
内部类Sync
//Sync 继承AbstractQueuedSynchronizer
//通过上篇ReentrantLock源码分析,我们知道该抽象类是一个同步阻塞队列,先进先出原则
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
//设置锁状态
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
//没有可用的共享资源返回1否则返回-1
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
//总结:该方法主要是判断解锁成功与否,如果本身没有被锁则解锁失败,但是如果解锁时发现锁状态大于1这时候也会解锁失败
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
//如果当前锁状态为释放状态则返回false
//如果锁状态不是释放状态则自旋将锁状态减一,如果自旋失败,则会无限制自旋,直到修改成功,这个时候返回锁释放与否
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
1. CountDownLatch countDown()方法
public void countDown() {
sync.releaseShared(1);
}
2. AbstractQueuedSynchronizer releaseShared(int arg) 方法
public final boolean releaseShared(int arg) {
//这里上面已经说明了,尝试释放锁,锁为释放状态才会返回ture
//这里也解释了为啥要new Sync(count)带一个count状态的锁
//试想下,当state为10时,第一个线程调用countDown方法,
//进来state减去1,state变为9不满足if条件,也就是锁资源不是释放状态,
//只有当第十个线程调用countDown方法,才会去调用doReleaseShared方法,去唤醒那个被wait方法等待的线程
if (tryReleaseShared(arg)) {
//走到这里证明没有可用的信号量了已经为0了,这里可以唤醒被等待的线程了
doReleaseShared();
return true;
}
return false;
}
3. AbstractQueuedSynchronizer doReleaseShared()方法
private void doReleaseShared() {
for (;;) {
Node h = head;
//头节点不等于尾节点,说明队列存在两个节点以上
if (h != null && h != tail) {
int ws = h.waitStatus;
//如果头节点状态为SIGNAL状态,则自旋将其状态改为0,如果自旋成功则
//唤醒头节点下一节点对应的线程
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
//上期ReentrantLock源码有说明
unparkSuccessor(h);
}
//如果头节点状态为0,则自旋将其状态改为PROPAGATE状态
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
//为啥有这个h == head判断
//其一,当头节点为空,或者头节点就是尾结点也就是说队列只有一个队列,则会
//跳出这个循环不做任何逻辑处理,这里暂时不考虑头节点为空的状况,头节点和尾结点相同,证明是一个单节点而且必然是一个没有线程的节点
//因为在初始化队列时,头节点就是一个僵尸节点
//其二,就是说走了上面的自旋逻辑,并且自旋成功了,
//但是发现这个时候的旧头节点,和当前的新头节点不一样,这时候会重新走一遍唤醒满足条件的节点线程
//那么h是绝对不会变的,变得只有head,而且只有这其中只有unparkSuccessor方法会去改变head
//因为unparkSuccessor会去唤醒等待的线程,一旦线程唤醒成功,则会去重新分配头节点
//这个时候就会出现新的头节点和旧的头节点不匹配
//但是这个时候不会break,会再次去判断并唤醒其他线程去争夺共享锁
if (h == head) // loop if head changed
break;
}
}
总结:
- 判断头节点状态,如果头节点状态为SIGNAL等待状态(在ReentrantLock里代表初始化等待状态),则将其状态改为0,并唤醒后节点的线程。
- 如果头节点状态为0则将其状态改为PROPAGATE状态
注意 for ( ; ; ) 这里是个死循环,如果自旋失败,则会无限制自旋下去
4. CountDownLatch await() 方法
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
5. AbstractQueuedSynchronizer acquireSharedInterruptibly(int arg)方法
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果当前线程中断则抛出中断异常,并清除中断标志
if (Thread.interrupted())
throw new InterruptedException();
//0 ? 1 :-1 tryAcquireShared(arg) 大于0 则表示 没有可用的信号量(共享锁)
//小于0 表示含有可用的信号量
//也就是如果小于0成立,说明原先初始化的共享锁没有完全分完,
//这个时候就要调用doAcquireSharedInterruptibly方法,将当前线程挂起,等待共享锁分完然后被唤醒
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
6.AbstractQueuedSynchronizer doAcquireSharedInterruptibly(int arg)方法
/**
* Acquires in shared interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//向队列末尾添加一个共享节点
//第一次进来时执行addaddWaiter方法后,头节点是一个空线程的节点,尾节点就是当前线程节点
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
//判断当前节点前节点是否为头节点
final Node p = node.predecessor();
if (p == head) {
//如果r >= 0 证明信号量被全部countDown掉了,此时可以
int r = tryAcquireShared(arg);
if (r >= 0) {
//走到这里,说明该节点为第二节点,且信号量为0了
//r 等于1
//设置将当前节点设置为头节点并解绑线程和前节点的关系
//某些条件成立下还回去唤醒后面线程
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
//修改前节点状态为SIGNAL状态,有必要的话会清除前面一些被取消的及节点
//前节点修改为SIGNAL状态后,当前节点就会被挂起直至被前节点唤醒
//注意这里被唤醒后如果发现有中断标志会抛出中断异常
//唤醒后就会重新走一遍是不是当前节点前节点是不是头节点,从而重新设置头节点
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
//走到这里,意思线程唤醒后发现被中断了,这时会抛出中断异常,且此时该节点因为在队列当中,所以需要将该节点改为取消状态,并重新调整队列或者唤醒后面等待节点对应的线程(细节的话请看上篇ReentrantLock源码分析)
if (failed)
cancelAcquire(node);
}
}
7. AbstractQueuedSynchronizer setHeadAndPropagate(Node node, int propagate) 方法
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
//将当前Node节点设置为头节点 这里也会将关联的线程和前节点解绑
setHead(node);
//前面tryAcquireShared(arg)>=0 那么propagate必然等于1 所以if条件是成立的
// h为旧的头节点,当前的node为head节点并且此时它的前节点和线程被解绑了
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
//由CountDownLatch创建的节点都是共享节点,所以这里必然成立
if (s == null || s.isShared())
//从队列中唤醒等待的线程
doReleaseShared();
}
}
总结
countDown 和 wait 方法没有强制性的先后关系,就是谁先执行的情况这是不可控制的
countDown 步骤
- 获取共享锁并共享锁状态减一
- 一旦共享锁获取完毕之后(状态为0了),就从阻塞队列中唤醒满足条件的线程
await 步骤
- 判断当前共享锁状态,如果共享锁没有分配完,才会往后面走(为啥这么判断?是因为如果共享锁在执行await方法前就已经分配完了,完全不用走后面流程挂起当前线程了)
- 如果线程被中断,则抛出中断异常
- 向阻塞队列末尾添加一个当前线程的节点
- 当前节点 前节点是头节点,则将当前节点设置为头节点,并从阻塞队列中唤醒满足条件的线程
- 当前节点 前节点不是头节点,此时如果前节点不是signal状态则初始化为该状态,有必要的话,会清理前面取消状态的节点
- 前节点为signal状态就挂起当前线程等待唤醒
- 被其他线程唤醒后,重新从第四部来过
- 最后如果在唤醒后发现中断了,会抛出中断异常,而且将当前节点改为取消状态,并清理队列中该节点的引用,有必要的话会唤醒头节点后面等待的线程