理解java的 CountDownLatch 和 CyclicBarrier

所谓CountDownLatch，字面理解就是计数，然后闭锁，所谓闭锁，就是在闭锁到达结束状态之前，这扇门一直是关闭着的，不允许任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。举个栗子说明，比如两个任务，任务一可以并发进行，任务二则要等到至少2个任务一完成后才能开始

public class CountDownLatchDemo {

    static final CountDownLatch countDownLatch = new CountDownLatch(2); 

    static class Mission1 implements Runnable{
        private String name;
        public Mission1(String name){
            this.name = name;
        }
        @Override
        public void run() {
            for(int i=0;i<5;i++){
                System.out.println(name + " misssion1 running " + i);
            }
            countDownLatch.countDown();
        }
    }

    static class Mission2 implements Runnable{
        private String name;
        public Mission2(String name){
            this.name = name;
        }
        @Override
        public void run() {
            try {
                countDownLatch.await();
                for(int i=0;i<5;i++){
                    System.out.println(name + " misssion2 running " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new Mission1("m11")).start();
        new Thread(new Mission1("m12")).start();
        new Thread(new Mission2("m2")).start();
    }
}

输出如下：
m12 misssion1 running 0
m12 misssion1 running 1
m12 misssion1 running 2
m12 misssion1 running 3
m11 misssion1 running 0
m12 misssion1 running 4
m11 misssion1 running 1
m11 misssion1 running 2
m11 misssion1 running 3
m11 misssion1 running 4
m2 misssion2 running 0
m2 misssion2 running 1
m2 misssion2 running 2
m2 misssion2 running 3
m2 misssion2 running 4

可见任务1 的两个线程是并行执行，二任务2则是2个任务1线程执行完毕后才启动。

说完CountDownLatch，再说说CyclicBarrier，CountDownLatch是做减法，减到0，await的方法就不再阻塞，那CyclicBarrier就是做加法，不同是CyclicBarrier的await本身就是做自增长，await达到数量后就可以集体往下了执行了

Demo示例

public class CyclicBarrierDemo {
    static CyclicBarrier barrier = new CyclicBarrier(3); 
    static class Mission implements Runnable{
        private String name;
        public Mission(String name){
            this.name = name;
        }
        @Override
        public void run() {
            for(int i=0;i<5;i++){
                System.out.println(name + " misssion1 running " + i);
                if(i==3){
                    try {
                        barrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        new Thread(new Mission("m1")).start();
        new Thread(new Mission("m2")).start();
        new Thread(new Mission("m3")).start();
    }
}

输出结果:
m1 misssion1 running 0
m3 misssion1 running 0
m3 misssion1 running 1
m3 misssion1 running 2
m3 misssion1 running 3
m2 misssion1 running 0
m1 misssion1 running 1
m2 misssion1 running 1
m1 misssion1 running 2
m2 misssion1 running 2
m1 misssion1 running 3
m2 misssion1 running 3
m2 misssion1 running 4
m3 misssion1 running 4
m1 misssion1 running 4

可以看到3个线程执行到3的时候就会停下来，等所有线程都到了3，再继续执行4