CyclicBarrier的用法

上一篇用CyclicBarrier实现了多个线程同时执行，CyclicBarrier字面意思就是一个可以循环使用的屏障。
这个类用2个构造方法：

//parties 就是需要的线程数
public CyclicBarrier(int parties)
//parties 就是需要的线程数,barrierAction就是线程到达屏障时优先执行的动作
public CyclicBarrier(int parties, Runnable barrierAction)

使用时，先new 一个实例，CyclicBarrier cyclicBarrier = new CyclicBarrier(10);,再就是在每个线程执行，cyclicBarrier.await();，线程就会处在等待，这个方法会抛出2个异常InterruptedException，BrokenBarrierException，后面再解释下这2个异常。
等待10个线程都执行了启动之后，就会到达屏障，每个线程就会继续执行下去。
上篇的例子中用了第一个构造函数，这次用另一个构造函数：

public class CyclicBarrierTest {
    /**
     * CyclicBarrier 适用再多线程相互等待，直到到达一个屏障点。并且CyclicBarrier是可重用的。
     */
    CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
        @Override
        public void run() {
            System.out.println("所有线程准备完毕！");
        }
    });

    private void runThread() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.submit(createThread(i));


        }
    }

    private Thread createThread(int i) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    cyclicBarrier.await();
                    System.out.println("Thread:" + Thread.currentThread().getName() + "准备完毕,time:" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.setName("name" + i);
        return thread;
    }

    public static void main(String[] args) {
        CyclicBarrierTest test = new CyclicBarrierTest();
        test.runThread();
    }
}

从执行结果看，先执行了构造方法中的线程：

所有线程准备完毕！
Thread:pool-1-thread-10准备完毕,time:1521040228703
Thread:pool-1-thread-3准备完毕,time:1521040228703
Thread:pool-1-thread-6准备完毕,time:1521040228703
Thread:pool-1-thread-7准备完毕,time:1521040228703
Thread:pool-1-thread-2准备完毕,time:1521040228703
Thread:pool-1-thread-1准备完毕,time:1521040228703
Thread:pool-1-thread-9准备完毕,time:1521040228703
Thread:pool-1-thread-8准备完毕,time:1521040228703
Thread:pool-1-thread-5准备完毕,time:1521040228703
Thread:pool-1-thread-4准备完毕,time:1521040228703

再看下异常：

 try {
    cyclicBarrier.await();
 } catch (InterruptedException e) {
    e.printStackTrace();
 } catch (BrokenBarrierException e) {
    e.printStackTrace();
}

在所有线程中，如果其中一个发生了中断，其他线程会抛出BrokenBarrierException。试想一下，如果一个中断了，其他的不抛出异常，那其他的线程都将会一直等待中。

看源码就更清楚了。下面源码只贴了一部分。

 private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
 
            final Generation g = generation;

            if (g.broken)
                throw new BrokenBarrierException();

            if (Thread.interrupted()) {
                breakBarrier();//设置generation.broken=true
                throw new InterruptedException();
            }

    }