本文正在参与「金石方案 . 分割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问出这么多花样