java.util.concurrent详解(一) Latch/Barrier

Java1.5提供了一个非常高效实用的多线程包：java.util.concurrent, 提供了大量高级工具，可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。从这篇blog起，我将跟大家一起共同学习这些新的Java多线程构件

1. CountDownLatch
    我们先来学习一下JDK1.5 API中关于这个类的详细介绍：
“一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。”

    这就是说，CountDownLatch可以用来管理一组相关的线程执行，只需在主线程中调用CountDownLatch 的await方法（一直阻塞），让各个线程调用countDown方法。当所有的线程都只需完countDown了，await也顺利返回，不再阻塞了。 在这样情况下尤其适用：将一个任务分成若干线程执行，等到所有线程执行完，再进行汇总处理。

    下面我举一个非常简单的例子。假设我们要打印1-100，最后再输出“Ok“。1-100的打印顺序不要求统一，只需保证“Ok“是在最后出现即可。

    解决方案：我们定义一个CountDownLatch，然后开10个线程分别打印（n-1）*10+1至（n-1）*10+10。主线程中调用await 方法等待所有线程的执行完毕，每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。

具体代码如下（本代码参考了JDK示例代码）：

Java代码  

1. import  java.util.concurrent.CountDownLatch;   
2. /**  
3.  * 示例：CountDownLatch的使用举例  
4.  * Mail: ken@iamcoding.com  
5.  * @author janeky  
6.  */   
7. public   class  TestCountDownLatch {   
8.      private   static   final   int  N =  10 ;   
9.   
10.      public   static   void  main(String[] args)  throws  InterruptedException {   
11.         CountDownLatch doneSignal =  new  CountDownLatch(N);   
12.         CountDownLatch startSignal =  new  CountDownLatch( 1 ); //开始执行信号   
13.   
14.          for  ( int  i =  1 ; i <= N; i++) {   
15.              new  Thread( new  Worker(i, doneSignal, startSignal)).start(); //线程启动了   
16.         }   
17.         System.out.println( "begin------------" );   
18.         startSignal.countDown(); //开始执行啦   
19.         doneSignal.await(); //等待所有的线程执行完毕   
20.         System.out.println( "Ok" );   
21.   
22.     }   
23.   
24.      static   class  Worker  implements  Runnable {   
25.          private   final  CountDownLatch doneSignal;   
26.          private   final  CountDownLatch startSignal;   
27.          private   int  beginIndex;   
28.   
29.         Worker( int  beginIndex, CountDownLatch doneSignal,   
30.                 CountDownLatch startSignal) {   
31.              this .startSignal = startSignal;   
32.              this .beginIndex = beginIndex;   
33.              this .doneSignal = doneSignal;   
34.         }   
35.   
36.          public   void  run() {   
37.              try  {   
38.                 startSignal.await();  //等待开始执行信号的发布   
39.                 beginIndex = (beginIndex -  1 ) *  10  +  1 ;   
40.                  for  ( int  i = beginIndex; i <= beginIndex +  10 ; i++) {   
41.                     System.out.println(i);   
42.                 }   
43.             }  catch  (InterruptedException e) {   
44.                 e.printStackTrace();   
45.             }  finally  {   
46.                 doneSignal.countDown();   
47.             }   
48.         }   
49.     }   
50. }  

[java] view plain copy

1.   

    总结：CounDownLatch对于管理一组相关线程非常有用。上述示例代码中就形象地描述了两种使用情况。第一种是计算器为1，代表了两种状态，开 关。第二种是计数器为N，代表等待N个操作完成。今后我们在编写多线程程序时，可以使用这个构件来管理一组独立线程的执行。

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

    我们在学习CountDownLatch的时候就提到了CyclicBarrier。两者究竟有什么联系呢？引用[JCIP]中的描述“The key difference is that with a barrier, all the threads must come together at a barrier point at the same time in order to proceed. Latches are for waiting for events; barriers are for waiting for other threads。CyclicBarrier等待所有的线程一起完成后再执行某个动作。这个功能CountDownLatch也同样可以实现。但是 CountDownLatch更多时候是在等待某个事件的发生。在CyclicBarrier中，所有的线程调用await方法，等待其他线程都执行完。

    举一个很简单的例子，今天晚上我们哥们4个去Happy。就互相通知了一下：晚上八点准时到xx酒吧门前集合，不见不散！。有个哥们住的近，早早就到了。有的事务繁忙，刚好踩点到了。无论怎样，先来的都不能独自行动，只能等待所有人

代码如下（参考了网上给的一些教程）

Java代码  

1. import  java.util.Random;   
2. import  java.util.concurrent.BrokenBarrierException;   
3. import  java.util.concurrent.CyclicBarrier;   
4. import  java.util.concurrent.ExecutorService;   
5. import  java.util.concurrent.Executors;   
6.   
7. public   class  TestCyclicBarrier {   
8.   
9.      public   static   void  main(String[] args) {   
10.        
11.         ExecutorService exec = Executors.newCachedThreadPool();        
12.          final  Random random= new  Random();   
13.            
14.          final  CyclicBarrier barrier= new  CyclicBarrier( 4 , new  Runnable(){   
15.              @Override   
16.              public   void  run() {   
17.                 System.out.println( "大家都到齐了，开始happy去" );   
18.             }});   
19.            
20.          for ( int  i= 0 ;i< 4 ;i++){   
21.             exec.execute( new  Runnable(){   
22.                  @Override   
23.                  public   void  run() {   
24.                      try  {   
25.                         Thread.sleep(random.nextInt( 1000 ));   
26.                     }  catch  (InterruptedException e) {   
27.                         e.printStackTrace();   
28.                     }   
29.                     System.out.println(Thread.currentThread().getName()+ "到了，其他哥们呢" );   
30.                      try  {   
31.                         barrier.await(); //等待其他哥们   
32.                     }  catch  (InterruptedException e) {   
33.                         e.printStackTrace();   
34.                     }  catch  (BrokenBarrierException e) {   
35.                         e.printStackTrace();   
36.                     }   
37.                 }});   
38.         }   
39.         exec.shutdown();   
40.     }   
41.   
42. }  

    关于await方法要特别注意一下，它有可能在阻塞的过程中由于某些原因被中断

    总结：CyclicBarrier就是一个栅栏，等待所有线程到达后再执行相关的操作。barrier 在释放等待线程后可以重用。