前置提要
什么是闭锁对象
闭锁对象(Latch Object)是一种同步工具,用于控制线程的等待和执行顺序。闭锁对象可以让一个或多个线程等待,直到特定的条件满足后才能继续执行。
在Java中,CountDownLatch就是一种常见的闭锁对象。它通过一个计数器来实现线程的等待。计数器的初始值设定为一个正整数,表示需要等待的事件数量。当一个线程完成了一个事件时,计数器的值就会减1。当计数器的值变为0时,所有等待的线程都会被释放,继续执行后续的操作。
闭锁对象的主要特点是,一旦计数器的值变为0,就不能再重新设置或重用。这意味着闭锁对象只能被触发一次,用于一次性的等待操作。
闭锁对象在多线程编程中非常有用,特别是在需要等待多个线程完成某个事件后再进行后续操作的场景。它提供了一种简单而有效的线程同步机制,可以确保线程按照特定的顺序执行。
除了CountDownLatch之外,CyclicBarrier也是一种闭锁对象。CyclicBarrier允许一组线程互相等待,直到所有线程都达到某个屏障点后再同时执行。与CountDownLatch不同的是,CyclicBarrier的计数器可以重置和重用,可以在多个循环中使用。
总结而言,闭锁对象是一种同步工具,用于控制线程的等待和执行顺序。它通过计数器来实现等待和触发的机制,确保线程按照特定的条件和顺序执行。CountDownLatch和CyclicBarrier是常见的闭锁对象实现。
CountDownLatch (倒计时器)
CountDownLatch
允许 count
个线程阻塞在一个地方,直至所有线程的任务都执行完毕。
CountDownLatch
是共享锁的一种实现,它默认构造 AQS 的 state
值为 count
。当线程使用 countDown()
方法时,其实使用了tryReleaseShared
方法以 CAS 的操作来减少 state
,直至 state
为 0 。当调用 await()
方法的时候,如果 state
不为 0,那就证明任务还没有执行完毕,await()
方法就会一直阻塞,也就是说 await()
方法之后的语句不会被执行。然后,CountDownLatch
会自旋 CAS 判断 state == 0
,如果 state == 0
的话,就会释放所有等待的线程,await()
方法之后的语句得到执行。
CountDownLatch 的两种典型用法
-
某一线程在开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n :
new CountDownLatch(n)
,每当一个任务线程执行完毕,就将计数器减 1countdownlatch.countDown()
,当计数器的值变为 0 时,在CountDownLatch上 await()
的线程就会被唤醒。一个典型应用场景就是启动一个服务时,主线程需要等待多个组件加载完毕,之后再继续执行。 -
实现多个线程开始执行任务的最大并行性。注意是并行性,不是并发,强调的是多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的
CountDownLatch
对象,将其计数器初始化为 1 :new CountDownLatch(1)
,多个线程在开始执行任务前首先coundownlatch.await()
,当主线程调用 countDown() 时,计数器变为 0,多个线程同时被唤醒。
CountDownLatch 的使用示例
public class CountDownLatchExample1 {// 请求的数量private static final int threadCount = 550;public static void main(String[] args) throws InterruptedException {// 创建一个具有固定线程数量的线程池对象(如果这里线程池的线程数量给太少的话你会发现执行的很慢)ExecutorService threadPool = Executors.newFixedThreadPool(300);final CountDownLatch countDownLatch = new CountDownLatch(threadCount);for (int i = 0; i < threadCount; i++) {final int threadnum = i;threadPool.execute(() -> {// Lambda 表达式的运用try {test(threadnum);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {countDownLatch.countDown();// 表示一个请求已经被完成}});}countDownLatch.await();threadPool.shutdown();System.out.println("finish");}public static void test(int threadnum) throws InterruptedException {Thread.sleep(1000);// 模拟请求的耗时操作System.out.println("threadnum:" + threadnum);Thread.sleep(1000);// 模拟请求的耗时操作}
}
上面的代码中,我们定义了请求的数量为 550,当这 550 个请求被处理完成之后,才会执行System.out.println("finish");
。
与 CountDownLatch 的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用 CountDownLatch.await()
方法。这样主线程的操作就会在这个方法上阻塞,直到其他线程完成各自的任务。
其他 N 个线程必须引用闭锁对象,因为他们需要通知 CountDownLatch
对象,他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()
方法来完成的;每调用一次这个方法,在构造函数中初始化的 count 值就减 1。所以当 N 个线程都调 用了这个方法,count 的值等于 0,然后主线程就能通过 await()
方法,恢复执行自己的任务。
再插一嘴:CountDownLatch
的 await()
方法使用不当很容易产生死锁,比如我们上面代码中的 for 循环改为:
for (int i = 0; i < threadCount-1; i++) {
这样就导致 count
的值没办法等于 0,然后就会导致一直等待。
CountDownLatch 的不足
CountDownLatch 是一次性的,计数器的值只能在构造方法中初始化一次,之后没有任何机制再次对其设置值,当 CountDownLatch 使用完毕后,它不能再次被使用。
CyclicBarrier(循环栅栏)
CyclicBarrier 和 CountDownLatch 非常类似,它也可以实现线程间的技术等待,但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。
CountDownLatch 的实现是基于 AQS 的,而 CycliBarrier 是基于 ReentrantLock(ReentrantLock 也属于 AQS 同步器)和 Condition 的.
CyclicBarrier 的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。CyclicBarrier 默认的构造方法是 CyclicBarrier(int parties)
,其参数表示屏障拦截的线程数量,每个线程调用await
方法告诉 CyclicBarrier 我已经到达了屏障,然后当前线程被阻塞。
再来看一下它的构造函数:
public CyclicBarrier(int parties) {
this(parties, null);
}public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
其中,parties 就代表了有拦截的线程的数量,当拦截的线程数量达到这个值的时候就打开栅栏,让所有线程通过。
CyclicBarrier 的应用场景
CyclicBarrier 可以用于多线程计算数据,最后合并计算结果的应用场景。比如我们用一个 Excel 保存了用户所有银行流水,每个 Sheet 保存一个帐户近一年的每笔银行流水,现在需要统计用户的日均银行流水,先用多线程处理每个 sheet 里的银行流水,都执行完之后,得到每个 sheet 的日均银行流水,最后,再用 barrierAction 用这些线程的计算结果,计算出整个 Excel 的日均银行流水。
CyclicBarrier 的使用示例
public class CyclicBarrierExample2 {// 请求的数量private static final int threadCount = 550;// 需要同步的线程数量private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);public static void main(String[] args) throws InterruptedException {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(10);for (int i = 0; i < threadCount; i++) {final int threadNum = i;Thread.sleep(1000);threadPool.execute(() -> {try {test(threadNum);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (BrokenBarrierException e) {// TODO Auto-generated catch blocke.printStackTrace();}});}threadPool.shutdown();}public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {System.out.println("threadnum:" + threadnum + "is ready");try {/**等待60秒,保证子线程完全执行结束*/cyclicBarrier.await(60, TimeUnit.SECONDS);} catch (Exception e) {System.out.println("-----CyclicBarrierException------");}System.out.println("threadnum:" + threadnum + "is finish");}}
运行结果,如下:
可以看到当线程数量也就是请求数量达到我们定义的 5 个的时候, await
方法之后的方法才被执行。
另外,CyclicBarrier 还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)
,用于在线程到达屏障时,优先执行barrierAction
,方便处理更复杂的业务场景。示例代码如下:
public class CyclicBarrierExample3 {// 请求的数量private static final int threadCount = 550;// 需要同步的线程数量private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {System.out.println("------当线程数达到之后,优先执行------");});public static void main(String[] args) throws InterruptedException {// 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(10);for (int i = 0; i < threadCount; i++) {final int threadNum = i;Thread.sleep(1000);threadPool.execute(() -> {try {test(threadNum);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (BrokenBarrierException e) {// TODO Auto-generated catch blocke.printStackTrace();}});}threadPool.shutdown();}public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {System.out.println("threadnum:" + threadnum + "is ready");cyclicBarrier.await();System.out.println("threadnum:" + threadnum + "is finish");}}
运行结果,如下:
CyclicBarrier 和 CountDownLatch 的区别
下面这个是国外一个大佬的回答:
CountDownLatch 是计数器,只能使用一次,而 CyclicBarrier 的计数器提供 reset 功能,可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从 jdk 作者设计的目的来看,javadoc 是这么描述它们的:
CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程,等待其他多个线程完成某件事情之后才能执行;) CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待,直到到达同一个同步点,再继续一起执行。)
对于 CountDownLatch 来说,重点是“一个线程(多个线程)等待”,而其他的 N 个线程在完成“某件事情”之后,可以终止,也可以等待。而对于 CyclicBarrier,重点是多个线程,在任意一个线程没有完成,所有的线程都必须等待。
CountDownLatch 是计数器,线程完成一个记录一个,只不过计数不是递增而是递减,而 CyclicBarrier 更像是一个阀门,需要所有线程都到达,阀门才能打开,然后继续执行。