CyclicBarrier使用详解

1. import java.util.Random;  
2. import java.util.concurrent.CyclicBarrier;  
3.   
4. /** *//** 
5.  * CyclicBarrier类似于CountDownLatch也是个计数器， 
6.  * 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数， 
7.  * 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 
8.  * CyclicBarrier就象它名字的意思一样，可看成是个障碍， 
9.  * 所有的线程必须到齐后才能一起通过这个障碍。 
10.  * CyclicBarrier初始时还可带一个Runnable的参数， 
11.  * 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。 
12.  */  
13. public class CyclicBarrierTest {  
14.   
15.     public static class ComponentThread implements Runnable {  
16.         CyclicBarrier barrier;// 计数器  
17.         int ID;    // 组件标识  
18.         int[] array;    // 数据数组  
19.   
20.         // 构造方法  
21.         public ComponentThread(CyclicBarrier barrier, int[] array, int ID) {  
22.             this.barrier = barrier;  
23.             this.ID = ID;  
24.             this.array = array;  
25.         }  
26.   
27.         public void run() {  
28.             try {  
29.                 array[ID] = new Random().nextInt(100);  
30.                 System.out.println("Component " + ID + " generates: " + array[ID]);  
31.                 // 在这里等待Barrier处  
32.                 System.out.println("Component " + ID + " sleep");  
33.                 barrier.await();  
34.                 System.out.println("Component " + ID + " awaked");  
35.                 // 计算数据数组中的当前值和后续值  
36.                 int result = array[ID] + array[ID + 1];  
37.                 System.out.println("Component " + ID + " result: " + result);  
38.             } catch (Exception ex) {  
39.             }  
40.         }  
41.     }  
42.     /** *//** 
43.      * 测试CyclicBarrier的用法 
44.      */  
45.     public static void testCyclicBarrier() {  
46.         final int[] array = new int[3];  
47.         CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {  
48.             // 在所有线程都到达Barrier时执行  
49.             public void run() {  
50.                 System.out.println("testCyclicBarrier run");  
51.                 array[2] = array[0] + array[1];  
52.             }  
53.         });  
54.   
55.         // 启动线程  
56.         new Thread(new ComponentThread(barrier, array, 0)).start();  
57.         new Thread(new ComponentThread(barrier, array, 1)).start();  
58.     }  
59.   
60.     public static void main(String[] args) {  
61.         CyclicBarrierTest.testCyclicBarrier();  
62.     }  
63. }  

说明：在main中执行testCyclicBarrier方法 
执行到CyclicBarrier barrier = new CyclicBarrier(2, new Runnable()...)时 
Runnable的参数是在CyclicBarrier的数目达到2时并且所有被CyclicBarrier.await()进入等待的线程被唤醒前执行。 
所以继续执行下面的两个线程 
new Thread(new ComponentThread(barrier, array, 0)).start(); 
new Thread(new ComponentThread(barrier, array, 1)).start(); 
执行public void run()方法，分别执行，互不影响 
执行到barrier.await();时该线程进入等待状态，当两个线程都执行完barrier.await();时，进入到new CyclicBarrier(2, new Runnable()...)里面的方法， 执行完里面的方法后，等待的两个线程再次被唤醒，继续各自执行线程后面的语句。