Java线程(十)：CyclicBarrier-用路障实现分阶段线程并发

       生活中我们常常会遇到这样的情景：10个朋友邀约去公园玩，彼此约好上午十点在小区门口集合然后一块租车过去，可能上午九点就会有人开始到了门口，但是因为人没有来全，必须等剩下的人，最后等到人全后大家一块到公园，到达公园后又约定分头开始玩，下午6点的时候公园门口集合，然后一块回去。在我们java编程过程中也会遇到类似的情况，要求必须几个线程都运行完后才可以进行下一步的操作，这就用到了循环路障类--CyclicBarrier。

       CyclicBarrier一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。它 还支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。

      CyclicBarrier有两种构造方法：

第一种：

[java]  view plain copy

1. CyclicBarrier(int parties) //创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在每个 barrier 上执行预定义的操作  

第二种：

[java]  view plain copy

1. CyclicBarrier(int parties, Runnable barrierAction)   // 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。  

 

下面通过一个实例进行说明：

[java]  view plain copy

1. public class CyclicBarrierTest {  
2.   
3.  public static void main(String[] args) {  
4.   ExecutorService service = Executors.newCachedThreadPool();  
5.   final  CyclicBarrier cb = new CyclicBarrier(3);  
6.   for(int i=0;i<3;i++){  
7.    Runnable runnable = new Runnable(){  
8.      public void run(){  
9.      try {  
10.       Thread.sleep((long)(Math.random()*10000));   
11.       System.out.println("线程" + Thread.currentThread().getName() +   
12.         "即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));        
13.       cb.await();  
14.         
15.       Thread.sleep((long)(Math.random()*10000));   
16.       System.out.println("线程" + Thread.currentThread().getName() +   
17.         "即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));  
18.       cb.await();   
19.       Thread.sleep((long)(Math.random()*10000));   
20.       System.out.println("线程" + Thread.currentThread().getName() +   
21.         "即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));        
22.       cb.await();        
23.      } catch (Exception e) {  
24.       e.printStackTrace();  
25.      }      
26.     }  
27.    };  
28.    service.execute(runnable);  
29.   }  
30.   service.shutdown();  
31.  }  
32. }  

      

      该例中定义了一个循环路障类：CyclicBarrier cb = new CyclicBarrier(3);在路障中设定必须要三个线程等待( cb.await())的时候才可以往下运行，从而达到下一个集合点。该例利用Thread.sleep((long)(Math.random()*10000)); 产生一个随机的休眠时间，用它来实现不同线程到达路障时的时间不同，到的早的线程需要等待到的晚的线程，当3个线程都cb,.await()；时。路障打开，3个线程再往下运行。程序运行的结果如下：

 

[java]  view plain copy

1. 线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候  
2. 线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候  
3. 线程pool-1-thread-3即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊  
4. 线程pool-1-thread-1即将到达集合地点2，当前已有1个已经到达，正在等候  
5. 线程pool-1-thread-2即将到达集合地点2，当前已有2个已经到达，正在等候  
6. 线程pool-1-thread-3即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊  
7. 线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候  
8. 线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候  
9. 线程pool-1-thread-2即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊  

       上例中是通过for循环产生了刚好3个线程，如果把产生的线程数改成4个的话，在这4个线程当中，只要有3个到达路障的时候，路障就会打开，其运行结果如下：

[java]  view plain copy

1. 线程pool-1-thread-3即将到达集合地点1，当前已有1个已经到达，正在等候  
2. 线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候  
3. 线程pool-1-thread-4即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊  
4. 线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候  
5. 线程pool-1-thread-1即将到达集合地点2，当前已有2个已经到达，正在等候  
6. 线程pool-1-thread-4即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊  
7. 线程pool-1-thread-2即将到达集合地点2，当前已有1个已经到达，正在等候  
8. 线程pool-1-thread-3即将到达集合地点2，当前已有2个已经到达，正在等候  
9. 线程pool-1-thread-4即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊  
10. 线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候  
11. 线程pool-1-thread-2即将到达集合地点3，当前已有2个已经到达，正在等候  
12. 线程pool-1-thread-1即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊