前言

Java中有很多的并发工具类，例如阻塞队列BlockingQueue，耗时任务处理工具Future、Callable，协调线程调度的CountDownLatch、CyclicBarrier、Semaphore，与锁相关的ReentrantLock、Condition之类，各有各的用处。
本次主要介绍协调线程调度的CountDownLatch、CyclicBarrier、Semaphore。

闭锁-CountDownLatch

闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门才会打开，并允许所有线程通过。当闭锁到达结束状态之后，将不会再改变状态，因此这扇门将永远保持打开状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行。

例如，我们有100个任务需要执行，要求必须在执行完这100个任务之后，才能继续执行后面的工作。如果使用CountDownLatch，这段逻辑会十分简单：

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(100);
        for(int i = 0 ; i < 100 ; i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "工作中。。。");
                    //每当有线程执行完，调用countDown方法，使闭锁数量减1
                    countDownLatch.countDown();
                }
            });
            thread.setName("subThread" + i);
            thread.start();
        }
        try {
            //在countDownLatch减为0之前，程序会一直在这里等待
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("100个线程已经执行完");
    }

运行这段程序，执行结果会是类似下面这样：

......
subThread90工作中。。。
subThread91工作中。。。
subThread92工作中。。。
subThread93工作中。。。
subThread94工作中。。。
subThread95工作中。。。
subThread96工作中。。。
subThread97工作中。。。
subThread98工作中。。。
subThread99工作中。。。
100个线程已经执行完

如果去掉程序中的CountDownLatch，那么“100个线程已经执行完”这句话可能会在这100个线程还没执行完时就已经打印。

栅栏-CyclicBarrier

上面我们看到，闭锁一旦进入终止状态，就不能被重置，因此它是“一次性”对象。
栅栏与闭锁类似，可以阻塞一系列线程，直到某个事件发生。区别在于，栅栏是可重用的，打个比方：跟团旅游，总是游览完一个景点，大家在某地集合，人到齐了之后，再一起出发，到下一个景点，如此往复。

    public static void main(String[] args) {
        //假设旅行团里有20个人
        CyclicBarrier cyclicBarrier = new CyclicBarrier(11);
        Random random = new Random();
        //一共5个景点
        for (int spot = 0; spot < 5; spot++) {
            //每个人视为一个线程，游览该景点
            for (int person = 0; person < 10; person++) {
                int finalSpot = spot;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("正在游览景点" + finalSpot);
                        try {
                            Thread.sleep(random.nextInt(10));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("已游览完景点" + finalSpot);
                        try {
                            //每个人游览完该景点，开始等待
                            cyclicBarrier.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
            try {
                //所有人都已经游览完该景点，继续游览下一景点
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

运行结果：

正在游览景点0
正在游览景点0
正在游览景点0
已游览完景点0
正在游览景点0
已游览完景点0
已游览完景点0
正在游览景点0
已游览完景点0
已游览完景点0
正在游览景点1
已游览完景点1
正在游览景点1
已游览完景点1
正在游览景点1
已游览完景点1
正在游览景点1
已游览完景点1
正在游览景点1
已游览完景点1
正在游览景点2
已游览完景点2
正在游览景点2
已游览完景点2
正在游览景点2
已游览完景点2
正在游览景点2
已游览完景点2
正在游览景点2
已游览完景点2
正在游览景点3
已游览完景点3
正在游览景点3
正在游览景点3
已游览完景点3
已游览完景点3
正在游览景点3
已游览完景点3
正在游览景点3
已游览完景点3
正在游览景点4
已游览完景点4
正在游览景点4
已游览完景点4
正在游览景点4
已游览完景点4
正在游览景点4
正在游览景点4
已游览完景点4
已游览完景点4

可以看到，当所有的人都游览完当前景点之后，大家才一起开始游览下一个景点，而且在整个过程中，复用了CyclicBarrier。

信号量-Semaphore

信号量用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。可以用来实现某种资源池。

    public static void main(String[] args){
        //假设可以同时工作的只有5个线程
        Semaphore semaphore = new Semaphore(5);
        for(int i = 0 ; i < 20 ; i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //当没有可用资源时，会阻塞在Semaphore.acquire处，直到有了新的资源
                        semaphore.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Time:" + System.currentTimeMillis() + "-" + Thread.currentThread().getName() + "工作中。。。");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //当前任务执行完，调用Semaphore.release释放资源
                    semaphore.release();
                }
            });
            thread.setName("subThread" + i);
            thread.start();
        }
    }

运行结果：

Time:1524060685536-subThread0工作中。。。
Time:1524060685536-subThread3工作中。。。
Time:1524060685536-subThread2工作中。。。
Time:1524060685536-subThread1工作中。。。
Time:1524060685536-subThread4工作中。。。
Time:1524060688536-subThread5工作中。。。
Time:1524060688536-subThread7工作中。。。
Time:1524060688536-subThread6工作中。。。
Time:1524060688536-subThread9工作中。。。
Time:1524060688536-subThread8工作中。。。
Time:1524060691536-subThread10工作中。。。
Time:1524060691536-subThread11工作中。。。
Time:1524060691536-subThread13工作中。。。
Time:1524060691536-subThread12工作中。。。
Time:1524060691536-subThread14工作中。。。
Time:1524060694536-subThread15工作中。。。
Time:1524060694536-subThread16工作中。。。
Time:1524060694536-subThread17工作中。。。
Time:1524060694536-subThread18工作中。。。
Time:1524060694536-subThread19工作中。。。

可以看到，每次只有5个线程在工作，当这5个线程工作结束后，后面的线程才会继续执行。