🏷️个人主页:牵着猫散步的鼠鼠
🏷️系列专栏:Java全栈-专栏
🏷️个人学习笔记,若有缺误,欢迎评论区指正
目录
1. 前言
2. CountDownLatch有什么用
3. CountDownLatch底层原理
3.1. countDown()方法
3.2. await()方法
4. CountDownLatch的基本使用
5. 总结
1. 前言
在很多的面经中都看到过提问 CountDownLatch 的问题,正好我们最近也在梳理学习AQS(抽象队列同步器)、CAS操作等知识,而 CountDownLatch 又是JUC包下一个比较常见的同步工具类,我们今天就继续来学一下这个同步工具类!
2. CountDownLatch有什么用
我们知道AQS是专属于构造锁和同步器的一个抽象工具类,基于它Java构造出了大量的常用同步工具,如ReentrantLock、Semaphore、ReentrantReadWriteLock、SynchronousQueue等等,我们今天的主角CountDownLatch同样如此。
CountDownLatch(倒时器)允许N个线程阻塞在同一个地方,直至所有线程的任务都执行完毕。CountDownLatch 有一个计数器,可以通过countDown()方法对计数器的数目进行减一操作,也可以通过await()方法来阻塞当前线程,直到计数器的值为 0。
这个就很类似我们的Moba类游戏的游戏加载过程,所有玩家几乎是一起进入游戏,加载快的玩家要等待加载慢的玩家,只有当全部玩家加载完成才能进入游戏,而CountDownLatch就类似于这个过程中的发令枪。
3. CountDownLatch底层原理
想要迅速了解一个Java类的内部构造,或者使用原理,最快速直接的办法就是看它的源码,这是很多初学者比较抵触的,会觉得很多封装起来的源码都晦涩难懂,诚然很多类内部实现是复杂,我也是慢慢从刚开始阅读Mybatis源码,到后来阅读JDK多线程相关的源码,尝试培养自己看源码的习惯,硬着头皮看段时间还是有不少收获的。
好的,我们直接进入CountDownLatch内部去看看它的底层原理吧
//几乎所有基于AQS构造的同步类,内部都需要一个静态内部类去继承AQS
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
}
private final Sync sync;
//构造方法中初始化count值
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
是不是很熟悉?对又是Sync,与 Semaphore信号量一样,几乎所有基于AQS构造的同步类,内部都需要一个静态内部类去继承AQS
3.1. countDown()方法
//核心方法,内部封装了共享模式下的线程释放
public void countDown() {
//内部类Sync,继承了AQS
sync.releaseShared(1);
}
//AQS内部的实现
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
//唤醒后继节点
doReleaseShared();
return true;
}
return false;
}
在CountDownLatch中通过countDown来减少倒计时数,这是最重要的一个方法,我们继续跟进源码看到它通过releaseShared()方法去释放锁,这个方法是AQS内部的默认实现方法,而在这个方法中再一次的调用了tryReleaseShared(arg),这是一个AQS的钩子方法,方法内部仅有默认的异常处理,真正的实现由CountDownLatch内部类Sync完成,如下
// 对 state 进行递减,直到 state 变成 0;
// 只有 count 递减到 0 时,countDown 才会返回 true
protected boolean tryReleaseShared(int releases) {
// 自选检查 state 是否为 0
for (;;) {
int c = getState();
// 如果 state 已经是 0 了,直接返回 false
if (c == 0)
return false;
// 对 state 进行递减
int nextc = c-1;
// CAS 操作更新 state 的值
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
当这个tryReleaseShared函数返回true时,也就是state扣减到了零,就会调用doReleaseShared唤醒CLH队列中阻塞等待的线程
3.2. await()方法
除了countDown()方法外,在CountDownLatch中还有一个重要方法就是await,在多线程环境下,线程的执行顺序并不一致,因此,对于一个倒时器也说,先开始的线程应该阻塞等待直至最后一个线程执行完成,而实现这一效果的就是await()方法!
// 等待
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 带有超时时间的等待
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
其中await()方法可以配置带有时间参数的,表示最大阻塞时间,当调用 await() 的时候,我们会调用aqs的一个模板方法acquireSharedInterruptibly(arg),如下:
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
Thread.interrupted()为判断线程书否为中断状态,如果为中断状态,抛出中断异常,否则会调用tryAcquireShared(arg)方法,tryAcquireShared方法为AQS的钩子函数,由静态内部类Snyc实现,如下
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
也就是说,当前state = 0就返回1,也就不会执行doAcquireSharedInterruptibly(arg),直接放行没有堵塞。否则会执行doAcquireSharedInterruptibly(arg)这个方法,这个方法内部主要是将当前线程加入CLH队列阻塞等待。
4. CountDownLatch的基本使用
由于await的实现步骤和countDown类似,我们就不贴源码了,大家自己跟进去也很容易看明白,我们现在直接来一个小demo感受一下如何使用CountDownLatch做一个倒时器
public class Test {
public static void main(String[] args) throws InterruptedException {
// 创建一个倒计数为 3 的 CountDownLatch
CountDownLatch latch = new CountDownLatch(3);
Thread service1 = new Thread(new Service("3", 1000, latch));
Thread service2 = new Thread(new Service("2", 2000, latch));
Thread service3 = new Thread(new Service("1", 3000, latch));
service1.start();
service2.start();
service3.start();
// 等待所有服务初始化完成
latch.await();
System.out.println("发射");
}
static class Service implements Runnable {
private final String name;
private final int timeToStart;
private final CountDownLatch latch;
public Service(String name, int timeToStart, CountDownLatch latch) {
this.name = name;
this.timeToStart = timeToStart;
this.latch = latch;
}
@Override
public void run() {
try {
Thread.sleep(timeToStart);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name);
// 减少倒计数
latch.countDown();
}
}
}
输出结果
3
2
1
发射
执行结果体现出了倒计时的效果每隔1秒进行3,2,1的倒数;其实除了倒计时器外CountDownLatch还有另外一个使用场景:实现多个线程开始执行任务的最大并行性
多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。
具体做法是: 初始化一个共享的 CountDownLatch 对象,将其计数器初始化为 1 (new CountDownLatch(1)),多个线程在开始执行任务前首先 coundownlatch.await(),当主线程调用 countDown() 时,计数器变为 0,多个线程同时被唤醒。
public class Test {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
try {
System.out.println("5位运动员就位!");
//等待发令枪响
countDownLatch.await();
System.out.println(Thread.currentThread().getName() + "起跑!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
// 裁判准备发令
Thread.sleep(2000);
//发令枪响
countDownLatch.countDown();
}
}
输出结果
5位运动员就位!
5位运动员就位!
5位运动员就位!
5位运动员就位!
5位运动员就位!
Thread-0起跑!
Thread-3起跑!
Thread-4起跑!
Thread-1起跑!
Thread-2起跑!
5. 总结
CountDownLatch 是一个多线程同步辅助类,它允许一个或多个线程等待一系列操作在其他线程中完成。这个机制类似于一场赛跑,选手们在起跑线准备,等待发令枪响后才能开始比赛。在 CountDownLatch 的场景中,线程们等待一个共同的信号,只有当计数器降至零时,它们才能继续执行。
CountDownLatch 提供了两个主要方法:countDown() 和 await()。countDown()方法用于将计数器减一,而 await() 方法会阻塞调用线程,直到计数器达到零。这种机制确保了所有线程都会等待必要的操作完成。
内部实现上,CountDownLatch 通过一个静态内部类 Sync 继承自 AbstractQueuedSynchronizer(AQS)。AQS 提供了一个框架,用于构建自定义的同步器。在 CountDownLatch 中,Sync 类通过重写 AQS 的钩子方法 tryReleaseShared() 和 tryAcquireShared() 来实现其同步机制。
- tryReleaseShared() 方法用于在共享模式下尝试释放资源
- tryAcquireShared() 方法用于在共享模式下尝试获取资源
我们可以发现,几乎所有基于AQS构造的同步类,实现原理都是差不多的,都是通过维护AQS中被volatile修饰的state变量作为竞态条件来实现线程同步。文章来源:https://www.toymoban.com/news/detail-855728.html
文章来源地址https://www.toymoban.com/news/detail-855728.html
到了这里,关于CountDownLatch倒计时器源码解读与使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!