Java并发编程之CountDownLatch
一.CountDownLatch 介绍
CountDownLatch是基于AQS共享锁构建的一种同步器，说白了就是一个同步工具，它是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下，它的主要应用场景有两种：
（1）可以让一个线程等待所有的其他线程执行完任务之后自己再执行自己的任务。
（2）可以让多个线程等待一个线程执行完任务之后，然后多个线程同时开始执行自己的任务。
二.CountDownLatch 方法
CountDownLatch的方法主要是：
（1）构造方法：
CountDownLatch(int count)
参数count控制线程的数量
（2）await()
阻塞当前调用的线程，直到count的值等于0才唤醒，除非执行了线程中断，否则
在没到达0之前，一直处于waiting状态
（3）await(long timeout, TimeUnit unit)
阻塞当前调用的线程，直到count的值等于0才唤醒，除非执行了线程中断或者指定的时间周期过期，否则在没到达0之前，一直处于waiting状态
（4）countDown()
每次调用对count的值减1，当这个值到达0的时候，会释放所有等待的线程。
（5）getCount()
返回当前count的数量了解一个类，当然是先从它的构造方法开始，CountDownLatch（int count）,count即为对应执行的线程数，可以看到CountDownLatch方法中，一旦创建count就固定了。与CountDownLatch的第一次交互是主线程等待其他线程，主线程创建多个子线程，在子线程启动之前，主线程立即调用 await 使线程处于阻塞状态，每个子线程执行完成会调用countDown方法，每次调用count 会减1，知道count = 0 时，释放线程，这时候主线程再执行自己的业务逻辑。
三. 使用场景
使用场景有很多，这里举例了一个比较常用的场景，应该程序启动之前，会对多个配置信息进行检查和验证，验证通过后再启动
AbstractCheckHelp 基类 ，实现Runnable ，提供vertify 抽象方法供子类继承
package com.lhy.jui.tools;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* @Author: lihuiyong
* @DATE : 2019/10/23
* @version:1.0.0
* @description: 抽象检查基类
*/
public abstract class AbstractCheckHelp implements Runnable {
public CountDownLatch countDownLatch;
public String serviceName;
public boolean signUp;
public AbstractCheckHelp(CountDownLatch countDownLatch, String serviceName) {
this.countDownLatch = countDownLatch;
this.serviceName = serviceName;
}
@Override
public void run() {
try {
signUp = vertify();
System.out.println(serviceName + "--检查完成");
} catch (Exception ex) {
ex.printStackTrace();
System.out.println(serviceName + " 检查发生异常");
} finally {
if (countDownLatch != null) {
countDownLatch.countDown();
}
}
}
/**
* 验证方法
*/
protected abstract boolean vertify() throws InterruptedException;
public String getServiceName() {
return serviceName;
}
public void setServiceName(String serviceName) {
this.serviceName = serviceName;
}
public boolean isSignUp() {
return signUp;
}
public void setSignUp(boolean signUp) {
this.signUp = signUp;
}
public static void main(String[] args) throws InterruptedException {
CountDownLatch c = new CountDownLatch(3);
AbstractCheckHelp dbConnectCheck = new DbConnectCheck(c, "数据库");
AbstractCheckHelp netWorkCheck = new NetWorkCheck(c, "网络服务");
AbstractCheckHelp initWorkCheck = new InitWorkCheck(c, "数据初始化");
List ts = new ArrayList<>();
ts.add(dbConnectCheck);
ts.add(netWorkCheck);
ts.add(initWorkCheck);
Thread s1 = new Thread(dbConnectCheck);
Thread s2 = new Thread(netWorkCheck);
Thread s3 = new Thread(initWorkCheck);
s1.start();
s2.start();
s3.start();
c.await();
for(AbstractCheckHelp s : ts){
System.out.println(s.getServiceName() +" 验证结果： " +s.isSignUp());
}
System.out.println("------检查完毕，启动应用--------");
}
}
子类 DbConnectCheck 检查数据库连接
/**
* @Author: lihuiyong
* @DATE : 2019/10/23
* @version:1.0.0
* @description: 检查数据库连接
*/
public class DbConnectCheck extends AbstractCheckHelp {
public DbConnectCheck(CountDownLatch countDownLatch,String serviceName){
super(countDownLatch,serviceName);
}
@Override
protected boolean vertify() throws InterruptedException {
Thread.sleep(10000l);
return true;
}
}
子类NetWorkCheck，检查网络状态
/**
* @Author: lihuiyong
* @DATE : 2019/10/23
* @version:1.0.0
* @description: 检查网络状态
*/
public class NetWorkCheck extends AbstractCheckHelp {
public NetWorkCheck(CountDownLatch countDownLatch,String serviceName){
super(countDownLatch,serviceName);
}
@Override
protected boolean vertify() throws InterruptedException {
Thread.sleep(6000l);
return true;
}
}另外一个子类 InitWorkCheck，初始化工具，代码同上不在列出来
运行AbstractCheckHelp main方法结果 ：
可以看到 主线程在 其他三个子线程检查结束之后调用；
c.await()阻塞了子线程的执行，每个子线程运行完成之后执行countDown，计数器-1，知道计数器的值为0 时，await才被唤醒，继续执行主线程，启动应用程序；这里需要注意c.await()方法的使用，有可能程序出现未知异常，没有处理，导致count计数器的值一直大于0，造成死锁；
所有通常会使用c.await(long timeOut，TimeUnit timeUnit)；防止死锁
更多类似的应用 比如在订单商品详情页中，组装商品详情，商品推荐，评价信息 等等
四. 实现原理
同ReentrantLock一样，依然是借助AQS的双端队列，来实现原子的计数-1，线程阻塞和唤醒
参考《Java并发学习之ReentrantLock的工作原理及使用姿势》
0. AbstractQueuedSynchronizer （简称AQS）
AQS是一个用于构建锁和同步容器的框架。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题
AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
static final class Node {
static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
//取值为 CANCELLED, SIGNAL, CONDITION, PROPAGATE 之一
volatile int waitStatus;
volatile Node prev;
volatile Node next;
// Link to next node waiting on condition,
// or the special value SHARED
volatile Thread thread;
Node nextWaiter;
}
1. 计数器的初始化
CountDownLatch内部实现了AQS，并覆盖了tryAcquireShared()和tryReleaseShared()两个方法，下面说明干嘛用的
通过前面的使用，清楚了计数器的构造必须指定计数值,这个直接初始化了 AQS内部的state变量
Sync(int count) {
setState(count);
}后续的计数-1/判断是否可用都是基于sate进行的
2. countDown() 计数-1的实现
// 计数-1
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) { // 首先尝试释放锁
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0) //如果计数已经为0，则返回失败
return false;
int nextc = c-1;
// 原子操作实现计数-1
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
// 唤醒被阻塞的线程
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) { // 队列非空，表示有线程被阻塞
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
// 头结点如果为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) // 没有线程被阻塞，直接跳出
break;
}
}上面截出计数减1的完整调用链
- 尝试释放锁
tryReleaseShared，实现计数-1
- 若计数已经小于0，则直接返回false
- 否则执行计数(AQS的state)减一
- 若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了
- 释放并唤醒阻塞线程
doReleaseShared
- 如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出
- 头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队
疑问一： 看到这个实现，是不是只要countDownLatch的计数为0了，所有被阻塞的线程都会被执行？
改下上面的demo，新增线程4，实现线程2的结果-线程1的结果
public class CountDownLatchDemo {
// ...省略重复
private int sub(int a, int b) {
return a - b;
}
public void calculate() {
countDownLatch = new CountDownLatch(2);
Thread thread1 = // ... ;
Thread thread2 = // ...;
Thread thread3 = new Thread(()-> {
try {
System.out.println(Thread.currentThread().getName() + " : 开始执行");
countDownLatch.await();
System.out.println(Thread.currentThread().getName() + " : 唤醒");
Thread.sleep(100); // 确保线程4先执行完相减
int ans = sum(tmpRes1, tmpRes2);
System.out.println(Thread.currentThread().getName() +
" : calculate ans: " + ans);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程3");
Thread thread4 = new Thread(()-> {
try {
System.out.println(Thread.currentThread().getName() + " : 开始执行");
countDownLatch.await();
System.out.println(Thread.currentThread().getName() + " : 唤醒");
int ans = sub(tmpRes2, tmpRes1);
Thread.sleep(200); // 保证线程3先输出执行结果，以验证线程3和线程4是否并发执行
System.out.println(Thread.currentThread().getName() +
" : calculate ans: " + ans);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程4");
thread3.start();
thread4.start();
thread1.start();
thread2.start();
}
public static void main(String[] args) throws InterruptedException {
CountDownLatchDemo demo = new CountDownLatchDemo();
demo.calculate();
Thread.sleep(1000);
}
}输出如下
线程4 : 开始执行
线程3 : 开始执行
线程2 : 开始执行
线程2 : calculate ans: 15050
线程1 : 开始执行
线程1 : calculate ans: 5005
线程3 : 唤醒
线程4 : 唤醒
线程3 : calculate ans: 20055
线程4 : calculate ans: 10045上面的实现中，线程3中sleep一段时间，确保线程4的计算会优先执行；线程4计算完成之后的sleep时间，以保证线程3计算完成并输出结果，然后线程4才输出结果；结合输出，这个期望是准确的，也就是说，线程3和线程4被唤醒后是并发执行的，没有先后阻塞顺序
即CountDownLatch计数为0之后，所有被阻塞的线程都会被唤醒，且彼此相对独立，不会出现独占锁阻塞的问题
3. await() 阻塞等待计数为0
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted()) // 若线程中端，直接抛异常
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
// 计数为0时，表示获取锁成功
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
// 阻塞，并入队
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) {
int r = tryAcquireShared(arg);
if (r >= 0) {
// 获取锁成功，设置队列头为node节点
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) // 线程挂起
&& parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}阻塞的逻辑相对简单
- 判断state计数是否为0，不是，则直接放过执行后面的代码
- 大于0，则表示需要阻塞等待计数为0
- 当前线程封装Node对象，进入阻塞队列
- 然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码
III. 小结
1. 使用注意
- 在创建实例时，必须指定初始的计数值，且应大于0
- 必须有线程中显示的调用了
countDown()计数-1方法；必须有线程显示调用了await()方法（没有这个就没有必要使用CountDownLatch了） - 由于await()方法会阻塞到计数为0，如果在代码逻辑中某个线程漏掉了计数-1，导致最终计数一直大于0，直接导致死锁了；
- 鉴于上面一点，更多的推荐
await(long, TimeUnit)来替代直接使用await()方法，至少不会造成阻塞死只能重启的情况 - 允许多个线程调用
await方法，当计数为0后，所有被阻塞的线程都会被唤醒
2. 实现原理
await内部实现流程:
- 判断state计数是否为0，不是，则直接放过执行后面的代码
- 大于0，则表示需要阻塞等待计数为0
- 当前线程封装Node对象，进入阻塞队列
- 然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码
countDown内部实现流程:
- 尝试释放锁
tryReleaseShared，实现计数-1
- 若计数已经小于0，则直接返回false
- 否则执行计数(AQS的state)减一
- 若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了
- 释放并唤醒阻塞线程
doReleaseShared
- 如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出
- 头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队