浅析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.await(); 
     
     //
     
     等待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 
     
     }