浅析Java中CountDownLatch用法

CountDownLatch如其所写，是一个倒计数的锁存器，当计数减至0时触发特定的事件。利用这种特性，可以让主线程等待子线程的结束。下面以一个模拟运动员比赛的例子加以说明。

  
  

   
    1 
   
   import
   
    java.util.concurrent.CountDownLatch;

   
    2 
   
    
   
   import
   
    java.util.concurrent.Executor;

   
    3 
   
    
   
   import
   
    java.util.concurrent.ExecutorService;

   
    4 
   
    
   
   import
   
    java.util.concurrent.Executors;

   
    5 
   
   

   
    6 
   
    
   
   public
   
    
   
   class
   
    CountDownLatchDemo {

   
    7 
   
       
   
   private
   
    
   
   static
   
    
   
   final
   
    
   
   int
   
    PLAYER_AMOUNT 
   
   =
   
    
   
   5
   
   ;

   
    8 
   
       
   
   public
   
    CountDownLatchDemo() {

   
    9 
   
           
   
   //
   
    TODO Auto-generated constructor stub    
   
   

   
   10 
   
    
   
       }

   
   11 
   
       
   
   /**
   
   

   
   12 
   
        * 
   
   @param
   
    args

   
   13 
   
        
   
   */
   
   

   
   14 
   
       
   
   public
   
    
   
   static
   
    
   
   void
   
    main(String[] args) {

   
   15 
   
           
   
   //
   
    TODO Auto-generated method stub

   
   16 
   
           
   
   //
   
   对于每位运动员，CountDownLatch减1后即结束比赛
   
   

   
   17 
   
   
   
           CountDownLatch begin 
   
   =
   
    
   
   new
   
    CountDownLatch(
   
   1
   
   );

   
   18 
   
           
   
   //
   
   对于整个比赛，所有运动员结束后才算结束
   
   

   
   19 
   
   
   
           CountDownLatch end 
   
   =
   
    
   
   new
   
    CountDownLatch(PLAYER_AMOUNT);

   
   20 
   
           Player[] plays 
   
   =
   
    
   
   new
   
    Player[PLAYER_AMOUNT];

   
   21 
   
           

   
   22 
   
           
   
   for
   
   (
   
   int
   
    i
   
   =
   
   0
   
   ;i
   
   <
   
   PLAYER_AMOUNT;i
   
   ++
   
   )

   
   23 
   
               plays[i] 
   
   =
   
    
   
   new
   
    Player(i
   
   +
   
   1
   
   ,begin,end);

   
   24 
   
           

   
   25 
   
           
   
   //
   
   设置特定的线程池，大小为5
   
   

   
   26 
   
   
   
           ExecutorService exe 
   
   =
   
    Executors.newFixedThreadPool(PLAYER_AMOUNT);

   
   27 
   
           
   
   for
   
   (Player p:plays)

   
   28 
   
               exe.execute(p);            
   
   //
   
   分配线程
   
   

   
   29 
   
   
   
           System.out.println(
   
   "
   
   Race begins!
   
   "
   
   );

   
   30 
   
           begin.countDown();

   
   31 
   
           
   
   try
   
   {

   
   32 
   
               end.wait();            
   
   //
   
   等待end状态变为0，即为比赛结束
   
   

   
   33 
   
   
   
           }
   
   catch
   
    (InterruptedException e) {

   
   34 
   
               
   
   //
   
    TODO: handle exception
   
   

   
   35 
   
   
   
               e.printStackTrace();

   
   36 
   
           }
   
   finally
   
   {

   
   37 
   
               System.out.println(
   
   "
   
   Race ends!
   
   "
   
   );

   
   38 
   
           }

   
   39 
   
           exe.shutdown();

   
   40 
   
       }

   
   41 
   
   }

  
  

接下来是Player类

  
  

   
    1 
   
   import
   
    java.util.concurrent.CountDownLatch;

   
    2 
   
   

   
    3 
   
   

   
    4 
   
   
   
   public
   
    
   
   class
   
    Player 
   
   implements
   
    Runnable {

   
    5 
   
   

   
    6 
   
       
   
   private
   
    
   
   int
   
    id;

   
    7 
   
       
   
   private
   
    CountDownLatch begin;

   
    8 
   
       
   
   private
   
    CountDownLatch end;

   
    9 
   
       
   
   public
   
    Player(
   
   int
   
    i, CountDownLatch begin, CountDownLatch end) {

   
   10 
   
           
   
   //
   
    TODO Auto-generated constructor stub
   
   

   
   11 
   
   
   
           
   
   super
   
   ();

   
   12 
   
           
   
   this
   
   .id 
   
   =
   
    i;

   
   13 
   
           
   
   this
   
   .begin 
   
   =
   
    begin;

   
   14 
   
           
   
   this
   
   .end 
   
   =
   
    end;

   
   15 
   
       }

   
   16 
   
   

   
   17 
   
       @Override

   
   18 
   
       
   
   public
   
    
   
   void
   
    run() {

   
   19 
   
           
   
   //
   
    TODO Auto-generated method stub
   
   

   
   20 
   
   
   
           
   
   try
   
   {

   
   21 
   
               begin.await();        
   
   //
   
   等待begin的状态为0
   
   

   
   22 
   
   
   
               Thread.sleep((
   
   long
   
   )(Math.random()
   
   *
   
   100
   
   ));    
   
   //
   
   随机分配时间，即运动员完成时间
   
   

   
   23 
   
   
   
               System.out.println(
   
   "
   
   Play
   
   "
   
   +
   
   id
   
   +
   
   "
   
    arrived.
   
   "
   
   );

   
   24 
   
           }
   
   catch
   
    (InterruptedException e) {

   
   25 
   
               
   
   //
   
    TODO: handle exception
   
   

   
   26 
   
   
   
               e.printStackTrace();

   
   27 
   
           }
   
   finally
   
   {

   
   28 
   
               end.countDown();    
   
   //
   
   使end状态减1，最终减至0
   
   

   
   29 
   
   
   
           }

   
   30 
   
       }

   
   31 
   
   }
  
  
  
  

   
   

  
  
  
  

   
   转自http://en.wikipedia.org/wiki/Double-checked_locking