CountDownLatch（倒计时器）、CyclicBarrier（循环栅栏）

CountDownLatch()：

CountDownLatch是一个非常实用的多线程控制工具类，这个工具通常用来控制线程等待，它可以让某一个线程等到倒计时结束，再开始执行。

CountDownLatch的构造函数接收一个整数为参数，即当前这个计数器的计数个数。

public CountDownLatch(int count)

下面演示下CountDownLatch的使用：

public class CountDownLatchDemo implements Runnable {

    static CountDownLatch count = new CountDownLatch(10);
    static CountDownLatchDemo demo = new CountDownLatchDemo();

    @Override
    public void run() {
        try {
            //模拟检查任务
            Thread.sleep(new Random().nextInt(10) * 1000);
            System.out.println("check complete!");
            count.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //测试
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for (int i = 0;i < 10;i++){
            exec.submit(demo);
        }
        //等待完成所有线程检查
        System.out.println("开始等待：" + Thread.currentThread().getName());
        count.await();
        //检查完成
        System.out.println("检查完成: " + Thread.currentThread().getName());
        exec.shutdown();
    }
}

输出结果：

开始等待：main
check complete!
check complete!
check complete!
check complete!
check complete!
check complete!
check complete!
check complete!
check complete!
check complete!
检查完成: main

 上述代码的第3行，生成一个CountDownLatch实例，计数数量为10，表示需要有10个线程完成任务，等待在CountDownLatch上的线程才能继续执行。代码第12行，使用了CountDownLatch.countDown()方法，也就是通知CountDownLatch，一个线程已经完成任务，倒计时可以减一了。在第25行，使用了CountDownLatch.await()方法，要求主线程等待所有10个任务完成后，主线程才能继续执行。这点从输出结果也可以看出，主线程一直等到10个线程完成后，才继续执行。

 CyclicBarrier()：

CyclicBarrier是另外一种多线程并发控制实用工具。和CountDownLatch非常类似，它也可以实现多线程间的计数等待，但它的功能比CountDownLatch更加复杂和强大。比如：我们把计数器设置为10，那么凑齐第一批10个线程后，计数器就会归零，然后接着凑齐下一批10个线程，这就是循环栅栏的含义。

CyclicBarrier可以接收一个参数做为barrierAction。这个barrierAction就是当计数器完成一次计数后，系统会执行的动作。构造函数如下，其中parties表示计数总数，也就是线程的参与总数。

public CyclicBarrier(int parties,Runnable barrierAction)

下面实例演示：

public class CyclicBarrierDemo {

    public static class Soldier implements Runnable{

        private String soldier;
        private final CyclicBarrier cyclicBarrier;

        public Soldier(String soldier,CyclicBarrier cyclicBarrier){
            this.soldier = soldier;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try{
                //等待所有士兵到齐
                cyclicBarrier.await();
                doWork();
                //等待所有士兵完成任务
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
        //任务
        void doWork(){
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                System.out.println(soldier + "完成任务！");
            }
        }
        //等待完成后，做的事
        public static class BarrierRun implements Runnable{

            boolean flag;
            int N;

            public BarrierRun(boolean flag,int N){
                this.flag = flag;
                this.N = N;
            }

            @Override
            public void run() {
                if (flag){
                    System.out.println("司令：士兵 " + N + "个，任务完成！");
                }else {
                    System.out.println("司令：士兵 " + N + "个，集合完毕！");
                    flag = true;
                }
            }
        }
        //测试
        public static void main(String[] args){
            final int N = 10;
            Thread[] allSoldier = new Thread[N];
            boolean flag = false;
            CyclicBarrier cyclicBarrier = new CyclicBarrier(N,new BarrierRun(flag,N));
            //设置屏障点， 主要是为了执行这个方法
            System.out.println("集合队伍！");
            for (int i = 0;i < N;i++){
                System.out.println("士兵"+ i + "报道！");
                allSoldier[i] = new Thread(new Soldier("士兵"+ i,cyclicBarrier));
                allSoldier[i].start();
            }
        }
    }
}

 上述代码的第63行，创建了CyclicBarrier实例，并将计数器设置为10，并要求在计数器达到指标后，执行49行run()方法。在第17行，每一个士兵线程都会等待，直到所有的士兵都集合完毕。集合完毕后，意味着CyclicBarrier的一次计数完成，当再一次调用CyclicBarrier.await()时，会进行下一次的计数。第18行，模拟了士兵的任务，当一个士兵完成任务后，代码的第19行就会让CyclicBarrier开始下一次的计数，这次计数的目的就是监控所有士兵是否全部完成了任务。一旦完成，49行的run()方法又会被调用，打印相应的信息。上述代码执行后，输出结果如下：

集合队伍！
士兵0报道！
士兵1报道！
士兵2报道！
士兵3报道！
士兵4报道！
士兵5报道！
士兵6报道！
士兵7报道！
士兵8报道！
士兵9报道！
司令：士兵 10个，集合完毕！
士兵1完成任务！
士兵7完成任务！
士兵9完成任务！
士兵0完成任务！
士兵3完成任务！
士兵4完成任务！
士兵6完成任务！
士兵2完成任务！
士兵5完成任务！
士兵8完成任务！
司令：士兵 10个，任务完成！ 

可以看出：整个的工作过程是这样的，先开始士兵集合，集合完毕后，打印集合完毕通知；开始任务，进行下一次的计数，所有任务完成后，打印任务完成通知。 

注意：

　　CyclicBarrier.await()方法可能会抛出两个异常。一个是 InterruptedException和 BrokenBarrierException ，InterruptedException表示线程在等待过程中，线程被中断，大部分线程等待的方法，都可能会抛出这个异常；BrokenBarrierException则表示当前的CyclicBarrier已经破损了，可能系统已经没有办法等待所有的线程到齐了，如果继续等待，可能就是徒劳无功的，因此，在这个CyclicBarrier上等待的其他线程，都会不再等待，以反常的方式离开。

CountDownLatch和CyclicBarrier的比较

　　❤ CountDownLatch：是一个（或者多个）线程，等待其他N个线程完成某件事情后才能执行；CyclicBarrier：N个线程互相等待，任何一个线程完成前，所有线程都必须等待。

　　❤ CountDownLatch：一次性的；CyclicBarrier：循环使用的，可以重复的；

　　❤ CountDownLatch基于AQS；CyclicBarrier基于锁和Condition；本质上都是依赖于volatile和CAS实现的。

 参考：《Java高并发程序设计》 葛一鸣 郭超 编著：