CyclicBarrier 使用

java.util.concurrent.CyclicBarrier类是一种同步机制，可以同步通过某种算法进行的线程。换句话说，它是所有线程必须等待的障碍，直到所有线程到达它为止，然后才能继续执行任何线程。
这是一个图表说明：

两个线程在CyclicBarriers中彼此等待

这些线程通过调用CyclicBarrier上的await（）方法来相互等待。一旦有N个线程在CyclicBarrier中等待，所有线程都被释放并且可以继续运行。

创建一个CyclicBarrier

当你创建一个CyclicBarrier时，你可以指定有多少个线程等待它，然后释放它们。
这里是你如何创建一个CyclicBarrier：

CyclicBarrier barrier = new CyclicBarrier(2);

在CyclicBarrier等待

这是一个线程如何在CyclicBarrier中等待

barrier.await();

您还可以为等待的线程指定超时。超时过后，线程也被释放，即使并非所有N个线程都在CyclicBarrier中等待。以下是您如何指定超时：

barrier.await(10, TimeUnit.SECONDS);

等待的线程在CyclicBarrier中等待，直到：

• 最后一个线程到达（调用await（））
• 线程被另一个线程中断（另一个线程调用它的interrupt（）方法）
• 另一个等待线程中断
• 另一个等待线程在CyclicBarrier等待时超时
• CyclicBarrier.reset（）方法由某个外部线程调用。

CyclicBarrier 例子

这是一个代码示例，向您展示如何使用CyclicBarrier：

Runnable barrier1Action = new Runnable() {
    public void run() {
        System.out.println("BarrierAction 1 executed ");
    }
};
Runnable barrier2Action = new Runnable() {
    public void run() {
        System.out.println("BarrierAction 2 executed ");
    }
};

CyclicBarrier barrier1 = new CyclicBarrier(2, barrier1Action);
CyclicBarrier barrier2 = new CyclicBarrier(2, barrier2Action);

CyclicBarrierRunnable barrierRunnable1 =
        new CyclicBarrierRunnable(barrier1, barrier2);

CyclicBarrierRunnable barrierRunnable2 =
        new CyclicBarrierRunnable(barrier1, barrier2);

new Thread(barrierRunnable1).start();
new Thread(barrierRunnable2).start();

这是CyclicBarrier Runnable类

public class CyclicBarrierRunnable implements Runnable{

    CyclicBarrier barrier1 = null;
    CyclicBarrier barrier2 = null;

    public CyclicBarrierRunnable(
            CyclicBarrier barrier1,
            CyclicBarrier barrier2) {

        this.barrier1 = barrier1;
        this.barrier2 = barrier2;
    }

    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() +
                                " waiting at barrier 1");
            this.barrier1.await();

            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() +
                                " waiting at barrier 2");
            this.barrier2.await();

            System.out.println(Thread.currentThread().getName() +
                                " done!");

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

这是执行上述代码的控制台输出。请注意，线程写入控制台的顺序可能因执行而异。有时Thread-0首先打印，有时首先打印Thread-1等

Thread-0 waiting at barrier 1
Thread-1 waiting at barrier 1
BarrierAction 1 executed
Thread-1 waiting at barrier 2
Thread-0 waiting at barrier 2
BarrierAction 2 executed
Thread-0 done!
Thread-1 done!

[原文]（http://tutorials.jenkov.com/java-util-concurrent/cyclicbarrier.html）