【同步器

java.util.concurrent包包含几个能帮助人们管理相互合作的线程集的类。这些机制具有为线程直间的共用集结点模式提供的‘预制功能’。如果有一个相互合作的线程满足这些行为模式之一，那么应该直接使用提供的类库而不是显示的使用锁与条件的集合。

【栅栏

CyclicBarrier类实现了一个集结点（rendezvous）称为栅栏（barrier）。考虑大量线程运行在一次计算的不同部分的情形。当所有部分都准备好时，需要把结果组合到一起。当一个线程完成了它那部分的任务后，我们让他运行到栅栏处。一旦所有的线程都到达了这个栅栏，栅栏就撤销，线程可以继续运行。如果任何一个线程在栅栏上等待时离开，那么栅栏就被破坏掉（线程离开可能时等待超时）。这种情况下，其他所有线程await方法上抛出BrokenBarrierException异常。那些已经在等待的线程立即中止await的调用。可以提供一个可选的栅栏动作，当所有线程到达栅栏时，就会执行这个动作。

Runnable barrierAction = ...
CyclicBarrier barrire = new CyclicBarrier(nthreads,barrierAction);

栅栏被称为时循环的，以为可以在所有等待的线程被释放后重用（这里与倒计时门闩不同，倒计时门闩只能使用一次）。

【常用方法

• public int await() throws InterruptedException,BrokenBarrierException：
  在所有参与者都已经在此 barrier 上调用 await方法之前，将一直等待。如果当前线程不是将到达的最后一个线程，出于调度目的，将禁用它，且在发生以下情况之一前，该线程将一直处于休眠状态：

    - 最后一个线程到达；或者
    - 其他某个线程中断当前线程；或者
    - 其他某个线程中断另一个等待线程；或者
    - 其他某个线程在等待 barrier 时超时；或者
    - 其他某个线程在此 barrier 上调用 reset()。
    

如果当前线程在进入此方法时已经设置了该线程的中断状态；或者在等待时被中断则InterruptedException，并且清除当前线程的已中断状态。

• 如果在线程处于等待状态时 barrier 被 reset()，或者在调用 await 时 barrier 被损坏，抑或任意一个线程正处于等待状态，则抛出 BrokenBarrierException 异常。
• 如果任何线程在等待时被 中断，则其他所有等待线程都将抛出 BrokenBarrierException 异常，并将 barrier 置于损坏状态。
• 如果当前线程是最后一个将要到达的线程，并且构造方法中提供了一个非空的屏障操作，则在允许其他线程继续运行之前，当前线程将运行该操作。
• 如果在执行屏障操作过程中发生异常，则该异常将传播到当前线程中，并将 barrier 置于损坏状态。
  返回：到达的当前线程的索引，其中，索引 getParties() - 1 指示将到达的第一个线程，零指示最后一个到达的线程.

抛出：

• InterruptedException - 如果当前线程在等待时被中断
• BrokenBarrierException - 如果另一个 线程在当前线程等待时被中断或超时，或者重置了 barrier，或者在调用 await 时 barrier 被损坏，抑或由于异常而导致屏障操作（如果存在）失败。

【例子

1.应用程序启动前，所有子线程准备工作完成，不需要返回值

public class Application{

    public static void main(String[] args) throws IOException, InterruptedException {
        //需要三个子线程准备
        CyclicBarrier barrier = new CyclicBarrier(3);
        //如果初始化barrier的线程数，与实际子线程数不同，barrier将会一直等待
        ExecutorService executor = Executors.newFixedThreadPool(3);
        executor.submit(new Thread(new InitThread(barrier, "子线程1")));
        executor.submit(new Thread(new InitThread(barrier, "子线程2")));
        executor.submit(new Thread(new InitThread(barrier, "子线程3")));

        executor.shutdown();
    }
}

class InitThread implements Runnable {
    // 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)
    private CyclicBarrier barrier;
    private String name;

    public InitThread(CyclicBarrier barrier, String name) {
        this.barrier = barrier;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000 * (new Random()).nextInt(8));
            System.out.println(name + " 初始化完成...");
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(name + " 开始运行！");
    }
}

2.应用程序启动前，所有子线程准备工作完成，需要返回值汇总

public class ApplicationNeedReturn {

    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        //需要三个子线程准备
        CyclicBarrier barrier = new CyclicBarrier(3);
        //如果初始化barrier的线程数，与实际子线程数不同，barrier将会一直等待
        ExecutorService executor = Executors.newFixedThreadPool(3);
        FutureTask<Long> time1 = new FutureTask<Long>(new InitThread2(barrier, "子线程1"));
        FutureTask<Long> time2 = new FutureTask<Long>(new InitThread2(barrier, "子线程2"));
        FutureTask<Long> time3 = new FutureTask<Long>(new InitThread2(barrier, "子线程3"));
        executor.submit(time1);
        executor.submit(time2);
        executor.submit(time3);
        long total = time1.get() + time2.get() + time3.get();
        System.out.println("准备完成，耗时：" + total);
        executor.shutdown();
    }
}

class InitThread2 implements Callable<Long> {

    private CyclicBarrier barrier;
    private String name;
    public InitThread2(CyclicBarrier barrier, String name) {
        this.barrier = barrier;
        this.name = name;
    }

    @Override
    public Long call() {
        long time = 1000 * (new Random()).nextInt(8);
        try {
            Thread.sleep(time);
            System.out.println(name + " 初始化完成... : " + time) ;
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        return time;
    }
}