Java多线程之CyclicBarrier

转 http://blog.csdn.net/huang_xw/article/details/7090152

    import java.util.Random;  
    import java.util.concurrent.CyclicBarrier;  
      
    /** 
     * CyclicBarrier类似于CountDownLatch也是个计数器， 
     * 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数， 
     * 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 
     * CyclicBarrier就象它名字的意思一样，可看成是个障碍， 
     * 所有的线程必须到齐后才能一起通过这个障碍。 
     * CyclicBarrier初始时还可带一个Runnable的参数， 
     * 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。 
     */  
    public class CyclicBarrierTest {  
      
        public static class ComponentThread implements Runnable {  
            CyclicBarrier barrier;// 计数器  
            int ID; // 组件标识  
            int[] array;    // 数据数组  
      
            // 构造方法  
            public ComponentThread(CyclicBarrier barrier, int[] array, int ID) {  
                this.barrier = barrier;  
                this.ID = ID;  
                this.array = array;  
            }  
      
            public void run() {  
                try {  
                    array[ID] = new Random().nextInt(100);  
                    System.out.println("Component " + ID + " generates: " + array[ID]);  
                    // 在这里等待Barrier处  
                    System.out.println("Component " + ID + " sleep...");  
                    barrier.await();  
                    System.out.println("Component " + ID + " awaked...");  
                    // 计算数据数组中的当前值和后续值  
                    int result = array[ID] + array[ID + 1];  
                    System.out.println("Component " + ID + " result: " + result);  
                } catch (Exception ex) {  
                }  
            }  
        }  
        /** 
         * 测试CyclicBarrier的用法 
         */  
        public static void testCyclicBarrier() {  
            final int[] array = new int[3];  
            CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {  
                // 在所有线程都到达Barrier时执行  
                public void run() {  
                    System.out.println("testCyclicBarrier run...");  
                    array[2] = array[0] + array[1];  
                }  
            });  
      
            // 启动线程  
            new Thread(new ComponentThread(barrier, array, 0)).start();  
            new Thread(new ComponentThread(barrier, array, 1)).start();  
        }  
      
        public static void main(String[] args) {  
            CyclicBarrierTest.testCyclicBarrier();  
        }  
    }  

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;
         }

         @Override
         public void run() {
             // TODO Auto-generated method stub
             try{
                 System.out.println("Worker's waiting");
                 //线程在这里等待，直到所有线程都到达barrier。
                 barrier.await();
                 System.out.println("ID:"+Thread.currentThread().getId()+" Working");
             }catch(Exception e){
                 e.printStackTrace();
             }
         }

     }

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
             //当所有线程到达barrier时执行
             @Override
             public void run() {
                 // TODO Auto-generated method stub
                 System.out.println("Inside Barrier");

             }
         });

         for(int i=0;i<THREAD_NUM;i++){
             new Thread(new WorkerThread(cb)).start();
         }
     }

 }
 /*
 以下是输出：
 Worker's waiting
 Worker's waiting
 Worker's waiting
 Worker's waiting
 Worker's waiting
 Inside Barrier
 ID:12 Working
 ID:8 Working
 ID:11 Working
 ID:9 Working
 ID:10 Working
 */
1. CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。 
2. CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。 
3. CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。