Countdown和CycliBarrier

1. CountdownLatch

1.1 概述

倒数计时器。一种典型的场景就是火箭发射。在火箭发射前，为了保证万无一失，往往还要进行各项设备、仪器的检查。只有等所有检查完毕后，引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程，等待所有检查线程全部完工后，再执行。

1.2 主要接口

// 初始化一个CountDownLatch，一般和线程数量相等
static final CountDownLatch end = new CountDownLatch(10);
// 每线程执行完一个任务，执行这句代码
end.countDown();
// 主线程调用此方法，等待所有任务执行完毕
end.await();
...

1.3 示意图

略

1.4 demo

package com.whc.countdown;

import java.util.concurrent.CountDownLatch;

/**
 * @ClassName CountDownLatchTest
 * @Description TODO
 * @Author Administrator
 * @Date 2019/3/10 19:15
 * @Version 1.0
 */
public class CountDownLatchTest {
    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);

        new Thread(() -> {
            try {
                System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                Thread.sleep(3000);
                System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                Thread.sleep(3000);
                System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        try {
            System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1.5 输出结果

等待2个子线程执行完毕...
子线程Thread-0正在执行
子线程Thread-1正在执行
子线程Thread-0执行完毕
子线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程

2. CyclicBarrier

2.1 概述

循环栅栏。clic意为循环，也就是说这个计数器可以反复使用。比如，假设我们将计数器设置为10。那么凑齐第一批10个线程后，计数器就会归零，然后接着凑齐下一批10个线程。

2.2 主要接口

//rrierAction就是当计数器一次计数完成后，系统会执行的动作
public CyclicBarrier(int parties, Runnable barrierAction)
await()

2.3 示意图

略

2.4 demo

package com.whc.countdown;

import java.util.concurrent.CyclicBarrier;

/**
 * @ClassName CyclicBarrierTest
 * @Description TODO
 * @Author Administrator
 * @Date 2019/4/9 21:57
 * @Version 1.0
 */
public class CyclicBarrierTest {
    // 自定义工作线程
    private static class Worker implements Runnable {
        private CyclicBarrier cyclicBarrier;

        public Worker(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + "开始等待其他线程");
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() + "开始执行");
                // 工作线程开始处理，这里用Thread.sleep()来模拟业务处理
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "执行完毕");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int threadCount = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);

        for (int i = 0; i < threadCount; i++) {
            System.out.println("创建工作线程" + i);
            Worker worker = new Worker(cyclicBarrier);
            new Thread(worker).start();
        }
    }
}

2.5 运行结果

创建工作线程0
创建工作线程1
创建工作线程2
Thread-2开始等待其他线程
Thread-1开始等待其他线程
Thread-0开始等待其他线程
Thread-0开始执行
Thread-2开始执行
Thread-1开始执行
Thread-0执行完毕
Thread-1执行完毕
Thread-2执行完毕

3. CyclicBarrier和CountDownLatch的区别

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置，可以使用多次，所以CyclicBarrier能够处理更为复杂的场景；
CyclicBarrier还提供了一些其他有用的方法，比如getNumberWaiting()方法可以获得CyclicBarrier阻塞的线程数量，isBroken()方法用来了解阻塞的线程是否被中断；
CountDownLatch允许一个或多个线程等待一组事件的产生，而CyclicBarrier用于等待其他线程运行到栅栏位置。

• join:阻塞当前线程,只有等子线程完全执行完成之后才能继续执行,不是那么灵活.
• CyclicBarrier:在多个线程中设置阻塞点,直到所有所有线程都执行到阻塞点,所有被阻塞的线程才同时进行执行。
• CountDownLatch:阻塞一个或多个线程,等待任务线程执行，任务线程到一定程度就可以调用countdown，然后不会阻塞任务线程,当计数器为0时主线程恢复执行.比join更加灵活一些，也可以实现CyclicBarrier的效果,就是麻烦一些。如果计数器为先设置为0,在进行await,那么对线程没有阻塞作用.

参考资料： 炼数成金、简书