CyclicBarrier

一个同步辅助类，允许一组线程互相等待，直到到达某个公共屏障点。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。 

CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

public class TestCyclicBarrier {  
 private static final int THREAD_NUM = 5;  
       
    public static class WorkerThread implements Runnable{  
        CyclicBarrier barrier;  
  
        public WorkerThread(CyclicBarrier b){  
            this.barrier = b;  
        }  
  
        public void run() {  
            try{  
                barrier.await();  
                System.out.println("ID:"+Thread.currentThread().getId()+" Working");  
            }catch(Exception e){  
                e.printStackTrace();  
            }  
        }  
    }  
      
    public static void main(String[] args) {  
        CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {  
            public void run() {  
                System.out.println("Inside Barrier");  
            }  
        });  
  
        Thread tr=null;  
        for(int i=0;i<THREAD_NUM-1;i++){  
            tr=new Thread(new WorkerThread(cb));  
            tr.start();  
        }  
        for(int i=0;i<THREAD_NUM+1;i++){  
            new Thread(new WorkerThread(cb)).start();  
        }  
    }  
}  

　　

public class CyclicBarrierTest3 {  
    static CyclicBarrier c = new CyclicBarrier(2);  
  
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {  
        Thread thread = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                try {  
                    c.await();  
                } catch (Exception e) {  
                }  
            }  
        });  
        thread.start();  
        thread.interrupt();  
        try {  
            c.await();  
        } catch (Exception e) {  
    //输出true  
            System.out.println(c.isBroken());  
        }  
    }  
}