JDK并发编程系列一：线程间的等待关系

CountDownLatch

内部维护一个计数器，用来控制一个线程等待多个线程。调用await()方法会阻塞，直到count=0，调用countDown()方法即count-1

示例：

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        //声明一个计数器为5的CountDownLatch对象
        CountDownLatch c = new CountDownLatch(5);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++){
            executorService.execute(() -> {
                System.out.println("我们得先执行完才能继续执行Main线程");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //表明已经有一个线程已经完成（更准确的说，到达了给定的条件点，让计数器减一）
                c.countDown();
            });
        }
        //等待，不论什么时候调用这个方法，都会检查计数器，直到计数器为0
        c.await();
        //当计数器为0之后，释放所有在c上面等待的线程，后面得以执行
        System.out.println("终于轮到我执行了");
        executorService.shutdown();
    }
}

输出如下：

我们得先执行完才能继续执行Main线程
我们得先执行完才能继续执行Main线程
我们得先执行完才能继续执行Main线程
我们得先执行完才能继续执行Main线程
我们得先执行完才能继续执行Main线程
终于轮到我执行了

上面示例只用到了一个CountDownLatch对象，比较简单，下面看一个稍微复杂一点的例子，需要同时维护线程开始和结束的一致性

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch c1 = new CountDownLatch(1);
        CountDownLatch c2 = new CountDownLatch(5);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++){
            final int j = i;
            executorService.execute(() -> {
                try {
                    /*没有号令都在这等着，不能动*/
                    c1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + (j + 1) + "个人跑完啦");
                //已经完成
                c2.countDown();
            });
        }
        System.out.println("1秒后统一开始");
        Thread.sleep(1000);
        //释放开始信号，所有在c1上等待的线程都被释放，同时执行
        c1.countDown();
        //等你们都完成
        c2.await();
        System.out.println("全部跑完");
        executorService.shutdown();
    }
}

输出如下：

1秒后统一开始
第2个人跑完啦
第4个人跑完啦
第5个人跑完啦
第3个人跑完啦
第1个人跑完啦
全部跑完

可能有些人已经注意到了，为什么示例二需要在main线程中调用Thread.sleep()休眠1秒钟再调用c1.countDown()呢？原因就是如果不这么做的话，那么在调用c1.countDown()的时候可能还有线程根本没有启动，因此会造成不同时开始的现象，怎么解决这个问题呢？就是CyclicBarrier

CyclicBarrier

上文说到，CountDownLatch可以控制线程统一执行完，而CyclicBarrier就是控制线程统一开始执行

用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行

修改示例二，取消sleep方法

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier c1 = new CyclicBarrier(5);
        CountDownLatch c2 = new CountDownLatch(5);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++){
            final int j = i;
            executorService.execute(() -> {
                try {
                    //必须要等到5个人同时到达这里才会继续执行后面的
                    c1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + (j + 1) + "个人跑完啦");
                c2.countDown();
            });
        }
        c2.await();
        System.out.println("全部跑完");
        executorService.shutdown();
    }
}