CountDownLatch、CyclicBarrier 复习_综合

1.CountDownLatch

CountDownLatch概念

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

CountDownLatch的用法

CountDownLatch典型用法：1、某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1 countdownLatch.countDown()，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

CountDownLatch典型用法：2、实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。

CountDownLatch的不足

CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

CountDownLatch（倒计时计算器）使用说明

方法说明

public void countDown()

　　递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少.

public boolean await(long timeout,TimeUnit unit) throws InterruptedException

　　使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回true值。

　　如果当前计数大于零，则出于线程调度目的，将禁用当前线程，且在发生以下三种情况之一前，该线程将一直出于休眠状态：

　　由于调用countDown()方法，计数到达零；或者其他某个线程中断当前线程；或者已超出指定的等待时间。

如果计数到达零，则该方法返回true值。
如果当前线程，在进入此方法时已经设置了该线程的中断状态；或者在等待时被中断，则抛出InterruptedException，并且清除当前线程的已中断状态。
如果超出了指定的等待时间，则返回值为false。如果该时间小于等于零，则该方法根本不会等待。

参数：

　　timeout-要等待的最长时间

　　unit-timeout 参数的时间单位

　　如果计数到达零，则返回true；如果在计数到达零之前超过了等待时间，则返回false

抛出：

　　InterruptedException-如果当前线程在等待时被中断

典型用法1：主线程等待子线程执行完成在执行

public class CountdownLatchExample {
public static void main(String[] args) throws InterruptedException {
final int totalThread = 10;
CountDownLatch countDownLatch = new CountDownLatch(totalThread);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < totalThread; i++) {
executorService.execute(() -> {
System.out.print("run..");
countDownLatch.countDown();
});
}
countDownLatch.await();
System.out.println("end");
executorService.shutdown();
}

countDownLatch.await(); 会让主线程等待

当countDownLatch.countDown(); 减到0的时候，才执行主线程

run..run..run..run..run..run..run..run..run..run..end

如果不使用 countDownLatch，则主线程不会等待其他10个线程，会先执行打印出 end

public class CountdownLatchExample1 {public static void main(String[] args) throws InterruptedException {final int totalThread = 10;CountDownLatch countDownLatch = new CountDownLatch(totalThread);ExecutorService executorService = Executors.newCachedThreadPool();for (int i = 0; i < totalThread; i++) {executorService.execute(() -> {System.out.print("run..");//  countDownLatch.countDown();});}//countDownLatch.await();System.out.println("end");// executorService.shutdown();}
}

run..run..run..run..run..run..run..run..end
run..run..

public class CountdownLatchTest1 {public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(3);final CountDownLatch latch = new CountDownLatch(3);for (int i = 0; i < 3; i++) {Runnable runnable = new Runnable() {@Overridepublic void run() {try {System.out.println("子线程" + Thread.currentThread().getName() + "开始执行");Thread.sleep((long) (Math.random() * 10000));System.out.println("子线程"+Thread.currentThread().getName()+"执行完成");latch.countDown();//当前线程调用此方法，则计数减一} catch (InterruptedException e) {e.printStackTrace();}}};executorService.execute(runnable);}try {System.out.println("主线程"+Thread.currentThread().getName()+"等待子线程执行完成...");latch.await();//阻塞当前线程，直到计数器的值为0System.out.println("主线程"+Thread.currentThread().getName()+"开始执行...");} catch (InterruptedException e) {e.printStackTrace();}}
}

主线程main等待子线程执行完成...
子线程pool-1-thread-1开始执行
子线程pool-1-thread-2开始执行
子线程pool-1-thread-3开始执行
子线程pool-1-thread-2执行完成
子线程pool-1-thread-3执行完成
子线程pool-1-thread-1执行完成
主线程main开始执行...

典型用法2：百米赛跑，4名运动员选手到达场地等待裁判口令，裁判一声口令，选手听到后同时起跑，当所有选手到达终点，裁判进行汇总排名

因为count为1，cdOrder.countDown()，直接唤醒 cdOrder.await(); 这四个等待的线程

public class CountdownLatchTest2 {public static void main(String[] args) {ExecutorService service = Executors.newCachedThreadPool();final CountDownLatch cdOrder = new CountDownLatch(1);final CountDownLatch cdAnswer = new CountDownLatch(4);for (int i = 0; i < 4; i++) {Runnable runnable = new Runnable() {@Overridepublic void run() {try {System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");cdOrder.await();System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");Thread.sleep((long) (Math.random() * 10000));System.out.println("选手" + Thread.currentThread().getName() + "到达终点");cdAnswer.countDown();} catch (InterruptedException e) {e.printStackTrace();}}};service.execute(runnable);}try {Thread.sleep((long) (Math.random() * 10000));System.out.println("裁判" + Thread.currentThread().getName() + "即将发布口令");cdOrder.countDown();System.out.println("裁判" + Thread.currentThread().getName() + "已发送口令，正在等待所有选手到达终点");cdAnswer.await();System.out.println("所有选手都到达终点");System.out.println("裁判" + Thread.currentThread().getName() + "汇总成绩排名");} catch (InterruptedException e) {e.printStackTrace();}}
}

选手pool-1-thread-1正在等待裁判发布口令
选手pool-1-thread-2正在等待裁判发布口令
选手pool-1-thread-4正在等待裁判发布口令
选手pool-1-thread-3正在等待裁判发布口令
裁判main即将发布口令
裁判main已发送口令，正在等待所有选手到达终点
选手pool-1-thread-1已接受裁判口令
选手pool-1-thread-3已接受裁判口令
选手pool-1-thread-4已接受裁判口令
选手pool-1-thread-2已接受裁判口令
选手pool-1-thread-4到达终点
选手pool-1-thread-2到达终点
选手pool-1-thread-3到达终点
选手pool-1-thread-1到达终点
所有选手都到达终点
裁判main汇总成绩排名

2.CyclicBarrier

用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，
直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以
它才叫做循环屏障。
CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会
执行一次。

CyclicBarrier 使用场景

可以用于多线程计算数据，最后合并计算结果的场景。

CyclicBarrier 与 CountDownLatch 区别

CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

public class CyclicBarrierDemo {static class TaskThread extends Thread {CyclicBarrier barrier;public TaskThread(CyclicBarrier barrier) {this.barrier = barrier;}@Overridepublic void run() {try {Thread.sleep(1000);System.out.println(getName() + " 到达栅栏 A");barrier.await();System.out.println(getName() + " 冲破栅栏 A");Thread.sleep(2000);System.out.println(getName() + " 到达栅栏 B");barrier.await();System.out.println(getName() + " 冲破栅栏 B");} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}}}public static void main(String[] args) {int threadNum = 5;CyclicBarrier barrier =new CyclicBarrier(threadNum, new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " 完成最后任务");}});for (int i=0;i<threadNum;i++){new TaskThread(barrier).start();}}
}

Thread-4 到达栅栏 A
Thread-0 到达栅栏 A
Thread-2 到达栅栏 A
Thread-1 到达栅栏 A
Thread-3 到达栅栏 A
Thread-3 完成最后任务
Thread-3 冲破栅栏 A
Thread-0 冲破栅栏 A
Thread-4 冲破栅栏 A
Thread-1 冲破栅栏 A
Thread-2 冲破栅栏 A
Thread-0 到达栅栏 B
Thread-2 到达栅栏 B
Thread-3 到达栅栏 B
Thread-1 到达栅栏 B
Thread-4 到达栅栏 B
Thread-4 完成最后任务
Thread-4 冲破栅栏 B
Thread-0 冲破栅栏 B
Thread-3 冲破栅栏 B
Thread-2 冲破栅栏 B
Thread-1 冲破栅栏 B