CyclicBarrier

CyclicBarrier类似于闭锁，它能够阻塞一组线程直到某个事件发生。
它与闭锁主要的区别在于，所有线程必须同时到达一个点，才能继续执行。
闭锁等待的是事件，是等待countDown()执行之后，之前等待的线程才可能继续执行。
栅栏是线程之间相互等待，然后同时到达一个点后在一起执行(可以中断、超时)。

public CyclicBarrier(int parties) {
        this(parties, null);
}

public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
}

public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
}

public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
}

样例：赛跑就是一个比较贴切的示例
public static void main (String[] args)
{
ExecutorService pool = Executors.newFixedThreadPool(4);
CyclicBarrier barrier = new CyclicBarrier(4, new Runnable()
{
@Override public void run ()
{
System.out.println("----各就各位----开始！");
}
});
for (int i = 0; i < 4; i++)
{
pool.execute(new Runner(barrier, i + 1));
}
pool.shutdown();
}

static class Runner implements Runnable
{
private CyclicBarrier barrier;
private int count;

public Runner (CyclicBarrier barrier, int count)
{
this.barrier = barrier;
this.count = count;
}

@Override public void run ()
{
try
{
Thread.sleep(new Random().nextInt(5000));
System.out.println(count + "号参赛者已准备!");
barrier.await();
System.out.println(count + "号参赛---GO!");
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (BrokenBarrierException e)
{
e.printStackTrace();
}
}
}

运行结果
1号参赛者已准备!
2号参赛者已准备!
3号参赛者已准备!
4号参赛者已准备!
----各就各位----开始！
4号参赛---GO!
1号参赛---GO!
2号参赛---GO!
3号参赛---GO!