老司机发车了，CountDownLatch：等与不等都在你

本文正在参与「金石方案 . 分割6万现金大奖」

哈喽咱们好，我是阿Q。

前几天咱们把 ReentrantLock的原理 进行了详细的解说，不熟悉的同学能够翻看前文，今日咱们介绍另一种基于 AQS 的同步东西——CountDownLatch。

CountDownLatch 被称为倒计时器，也叫闭锁，是 juc 包下的东西类，一起也是同享锁的一种完结。它的作用是能够让一个或多个线程等候，直到所有线程的使命都履行完之后再持续往下履行。

举个简单的比如：阿Q高中时期都是乘坐大巴往复于县城与农村，那时的司机为了利益的最大化，会在轿车满员的情况下才会发车。

假如咱们把乘客去车站乘车比作一个一个的线程，那 CountDownLatch 做的事便是等咱们到齐之前的等候作业。

咱们从源码的视点来剖析下它的作业原理

①谁来决定公交车上的座位数？

公交车上的座位数是由轿车制造商决定的，在 CountDownLatch 中也会存在这样一个值 count，用来表明需求等候的线程个数。

count 值是在 CountDownLatch 的构造函数中进行初始化的

public CountDownLatch(int count) {
	if (count < 0) throw new IllegalArgumentException("count < 0");
	this.sync = new Sync(count);
}
Sync(int count) {
 //设置 AQS 中的 state 为 count 值
	setState(count);
}

计数值 count 是一次性的，当它的值减为0后就不会再变化了，这也是其存在的不足之处。

②谁来确认乘客全部到齐？

在轿车发车前检票员会对车上的乘客数量进行清点，假如满员了就会通知司机开车。

当然也能够选用这种办法：在得知车座位数的前提下，每上来一位乘客，座位数进行减一操作。CountDownLatch 便是选用的上述办法，它的 countDown() 办法会对 state 的值履行减1操作。

让咱们从源码的视点来认识一下该办法。

public void countDown() {
 //开释同享锁
	sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
	if (tryReleaseShared(arg)) {
		doReleaseShared();
		return true;
	}
	return false;
}

先测验开释锁，假如回来 true，则履行开释操作，反之不履行。咱们剖析下上边的两个办法

protected boolean tryReleaseShared(int releases) {
	for (;;) {
  //获取当时等候的线程数量
		int c = getState();
  //等候线程数为0，表明没有等候线程，故不需求开释锁资源
		if (c == 0)
			return false;
  //履行减1操作
		int nextc = c-1;
  //自旋+CAS将state的属性值-1
		if (compareAndSetState(c, nextc))
			return nextc == 0;
	}
}

最终一步中，假如减一之后为0，则阐明没有其它线程等候，需求履行开释锁操作，回来 true，反之不需求。

在开端剖析 doReleaseShared() 之前，咱们先来补全一下 AQS 中 waitStatus 的状况阐明

• 初始化状况：0，表明当时节点在同步行列中，等候获取锁；
• CANCELLED：1，表明当时节点撤销获取锁；
• SIGNAL：-1，表明后续节点等候当时节点唤醒；
• CONDITION：-2，表明当时线程正在条件等候行列中；
• PROPAGATE：-3，同享模式，前置节点唤醒后续节点后，唤醒操作无条件传达下去；

/**
 * 开释锁：唤醒后续节点
 */
private void doReleaseShared() {
	for (;;) {
		Node h = head;
  //不是null 且不为尾节点，因为尾节点没有后续节点需求唤醒了
		if (h != null && h != tail) {
			int ws = h.waitStatus;
   //只要状况为 -1 才能够唤醒后续节点
			if (ws == Node.SIGNAL) {
				//将waitStatus设置为0失利会持续循环
				if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
					continue;
				unparkSuccessor(h);
			}
			//将waitStatus设置为PROPAGATE失利会持续循环
			else if (ws == 0 &&
					 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
				continue;                
		}
		if (h == head)                   
			break;
	}
}

unparkSuccessor() 办法用于唤醒 AQS 中被挂起的线程，在ReentrantLock的原理中讲过了，此处不再赘述。

小结：当线程运用 countDown() 办法时，其实是运用了 tryReleaseShared() 办法以 CAS 的操作来削减 state ,直至 state 为 0 ，进而开释锁资源，唤醒后续节点。

③谁来发车？

肯定是司机来发车呀，那咱们的 CountDownLatch 是怎么完结的呢？

CountDownLatch 中的 await() 办法，便是等候线程的总开关，当发现 state 的值为0时会开释所有的等候线程，发车了。

咱们从源码视点来看下它是怎么作业的

public void await() throws InterruptedException {
	sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
		throws InterruptedException {
 //假如线程中断了，直接抛出中断反常
	if (Thread.interrupted())
		throw new InterruptedException();
 //假如小于0，代表 state 不为0，即还有使命未履行完毕，会履行获取同享锁的操作
	if (tryAcquireShared(arg) < 0)
		doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
	return (getState() == 0) ? 1 : -1;
}

咱们来看看它到底是怎么获取同享锁的

private void doAcquireSharedInterruptibly(int arg)
	throws InterruptedException {
	//将当时线程封装成node放到队尾
	final Node node = addWaiter(Node.SHARED);
	boolean failed = true;
	try {
		for (;;) {
			final Node p = node.predecessor();
			if (p == head) {
				int r = tryAcquireShared(arg);
				//state为0，表明此时等候线程全部履行完毕，r为1。
				if (r >= 0) {
					setHeadAndPropagate(node, r);
					p.next = null;
					failed = false;
					return;
				}
			}
			//从当时node节点向前寻觅有用节点，并保证有用节点的waitStatus状况为-1
			if (shouldParkAfterFailedAcquire(p, node) &&
				//挂起线程
				parkAndCheckInterrupt())
				//在拿锁的期间，假如被中断了，那么会抛出反常，撤销拿锁
				throw new InterruptedException();
		}
	} finally {
		if (failed)
			//将当时节点设置为失效节点，并挂到最近的有用节点后边，上文中有图解
			cancelAcquire(node);
	}
}

其中最重要的便是 setHeadAndPropagate() 办法

private void setHeadAndPropagate(Node node, int propagate) {
	Node h = head; 
	//将当时node设置为head，并将node的线程置为空
	setHead(node);
	if (propagate > 0 || h == null || h.waitStatus < 0 ||
		(h = head) == null || h.waitStatus < 0) {
		Node s = node.next;
		if (s == null || s.isShared())
			//开释锁：唤醒后续节点
			doReleaseShared();
	}
}

小结：当线程运用 await() 办法时会将当时线程封装成 node 参加AQS 行列中，假如发现 state 不为0，阐明还有使命未履行完结，持续堵塞；假如 state 为0，会开释掉所有的等候线程，履行 await() 之后的数据。

流程图了解一下

理论讲完了，那咱们用代码来演示下上边的比如

public static void main(String[] args) throws InterruptedException {
	int count = 10;
	//设置线程池并发数
	ExecutorService executorService = Executors.newFixedThreadPool(count);
	//假设大巴能够拉十个乘客，初始化state
	CountDownLatch countDownLatch = new CountDownLatch(count);
	for (int i = 0; i < count; i++) {
		final int num = i;
		executorService.execute(()->{
			try {
				Thread.sleep((long) (new Random().nextDouble() * 3000) + 1000);
				System.out.println("乘客坐在了"+ (num +1) + "号座位上");
			} catch (InterruptedException exception) {
				exception.printStackTrace();
			}finally {
				countDownLatch.countDown();
			}
		});
	}
	System.out.println("司机等候乘客上车");
	countDownLatch.await();
	System.out.println("发车了");
	executorService.shutdown();
}

履行成果如下：

细心地同学肯定会问了：假如遇上刮风下雨，来坐车的人少了，那已经上车的乘客岂不是回不了家了？

当然不是了，大巴其实也是有时刻观念的，即使车上的乘客不满员到了必定的时刻司机也会发车的，另外还会在路上顺路稍几个人上车。那咱们的 CountDownLatch 是怎么完结的呢？

CountDownLatch 还提供了一个 await(long timeout, TimeUnit unit)办法，在必定的时刻距离内会堵塞当时线程，等候 count 个线程履行使命，一旦超出了等候时刻，便会持续往下履行。

咱们将上边的countDownLatch.await();替换为countDownLatch.await(3, TimeUnit.SECONDS);，履行成果如下所示

上文中的比如是 CountDownLatch 的其中一种用法，即主线程等候其他线程履行完毕之后再履行。它还有另一种用法，即完结多个线程开端履行使命的最大并行性，相似发令枪响前，运动员统一在起跑线就位的场景。

public static void main(String[] args) throws InterruptedException {
	//设置线程池并发数
	ExecutorService executorService = Executors.newFixedThreadPool(10);
	CountDownLatch countDownLatch = new CountDownLatch(1);
	//一组有6名运动员
	for (int i = 0; i < 6; i++) {
		final int num = i;
		executorService.execute(()->{
			try {
				System.out.println("运动员"+ (num+1) +"等候发令枪响");
				countDownLatch.await();
				System.out.println("运动员"+ (num+1) +"开端起跑");
			} catch (InterruptedException exception) {
				exception.printStackTrace();
			}
		});
	}
	Thread.sleep(3000);
	countDownLatch.countDown();
	System.out.println("发令枪响");
	executorService.shutdown();
}

履行成果如下

说了这么多，都是样例？你有没有在项目中应用过呢？

答复当然是“Yes”了，之前的运营端有个统计页面，要求统计用户新增数量、订单数量、商品交易总额等多张表的指标值，为了进步履行速率，我就启用了多个子线程分别去统计，用 CountDownLatch 来等候它们的统计成果。

今日的内容到这里就完毕了，期望对咱们有所协助，咱们下期再见。写文不易，期望咱们能够一键三连：点赞、转发、在看。

回复：面试题、pdf、简历、材料、3113有超赞的粉丝福利，也能够来技术群来讨论问题呦。

引荐阅读

实战：画了几张图，总算把OAuth2搞清楚了

重磅出击，20张图带你完全了解ReentrantLock加锁解锁的原理

领导看了我写的封闭超时订单，让我出门左转！

看了同事写的代码，我竟然开端默默的仿照了。。。

面试官太难伺候？一个try-catch问出这么多花样