CyclicBarrier用法

CountDownLatch和CyclicBarrier

CyclicBarrier在用法上其实跟CountDownLatch十分相似，但是前者功能更加强大。
CountDownLatch举例：

CountDownLatch countDownLatch=new CountDownLatch(n); 

当程序多次执行countDownLatch.countDown();导致计数器n=0时，阻塞的线程都将同时被唤醒。但是此时的n已经是等于0了，也就是说这个计数器就是一次性的。

CyclicBarrier举例：

CyclicBarrier cyclicBarrier = new CyclicBarrier(n);

CyclicBarrier也能实现countDownLatch的功能，并且它的计数器n是可以被重置的，也就是说n=0线程被唤醒后，n又能重新回到原有值。

CyclicBarrier实现CountDownLatch的功能

public class CycleBarrierTest {
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
        // 当计数器为0时，立即执行
        @Override
        public void run() {
            System.out.println("汇总线程：" + Thread.currentThread().getName() + " 任务合并。");
        }
    });

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 将线程A添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程A：" + Thread.currentThread().getName() + "执行任务。");
                    System.out.println("线程A：到达屏障点");
                    cyclicBarrier.await();
                    System.out.println("线程A：退出屏障点");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程B添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程B：" + Thread.currentThread().getName() + "执行任务。");
                    System.out.println("线程B：到达屏障点");
                    cyclicBarrier.await();
                    System.out.println("线程B：退出屏障点");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 关闭线程池
        executorService.shutdown();
    }
}

执行结果：

线程A：pool-1-thread-1执行任务。
线程A：到达屏障点
线程B：pool-1-thread-2执行任务。
线程B：到达屏障点
汇总线程：pool-1-thread-2 任务合并。
线程B：退出屏障点
线程A：退出屏障点

结果分析：
CyclicBarrier指定了计数器为2，线程A执行cyclicBarrier.await();到达屏障点阻塞，此时计数器等于2-1=1，线程B也执行cyclicBarrier.await();到达屏障点阻塞，此时计数器等于0，CyclicBarrier里的任务会立即执行，执行完成后，线程A和B也被同时唤醒继续执行。

CyclicBarrier相对CountDownLatch的优化

public class CycleBarrierTest2 {
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2);

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 将线程A添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程A：" + Thread.currentThread().getName() + "执行第1步。");
                    cyclicBarrier.await();
                    System.out.println("线程A：" + Thread.currentThread().getName() + "执行第2步。");
                    cyclicBarrier.await();
                    System.out.println("线程A：" + Thread.currentThread().getName() + "执行第3步。");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程B添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程B：" + Thread.currentThread().getName() + "执行第1步。");
                    cyclicBarrier.await();
                    System.out.println("线程B：" + Thread.currentThread().getName() + "执行第2步。");
                    cyclicBarrier.await();
                    System.out.println("线程B：" + Thread.currentThread().getName() + "执行第3步。");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 关闭线程池
        executorService.shutdown();
    }
}

执行结果：

线程A：pool-1-thread-1执行第1步。
线程B：pool-1-thread-2执行第1步。
线程B：pool-1-thread-2执行第2步。
线程A：pool-1-thread-1执行第2步。
线程A：pool-1-thread-1执行第3步。
线程B：pool-1-thread-2执行第3步。

结果分析：
CyclicBarrier指定了计数器为2，线程A和线程B都分别执行了2次cyclicBarrier.await();这样导致的效果就是：每个线程分阶段完成任务，等所有线程都完成了第1步，然后才能接着执行第2步，等所有线程都完成了第2步，才能执行第3步。

图解：

CyclicBarrier的特性就在于它的计数器是可以重置的，这也就有了上图那种多屏障的情况，虽然第一次调用await使得计数器等于0屏障1失效，但是后续如果继续调用await，屏障还能继续使用，这也就是计数器重置的好处。而CountDownLatch第一次屏障失效后，就结束了。