Java.concurrent.*

Java concurrent

 

CountDownLatch 使用詳解

CountDownLatch下面例子比較簡單

Java代碼  

import  java.util.concurrent.CountDownLatch;  
  
public   class  CountDownLatchTest {  
     
    static   class  SimpleThread  extends  Thread {  
  
        private  CountDownLatch latch;  
  
        public  SimpleThread(CountDownLatch latch){  
            this .latch = latch;  
        }  
         
        @Override   
        public   void  run() {  
            System.out.println(this  +  " RUNNING." );  
            latch.countDown();  
        }  
         
    }  
  
    public   static   void  main(String[] args)  throws  InterruptedException {  
        CountDownLatch latch = new  CountDownLatch( 5 );  
         
        for ( int  i= 0 ; i< 5 ; i++) {  
            new  SimpleThread(latch).start();  
        }  
         
        //等待所有子線程處理完成。   
        latch.await();  
        System.out.println("Over" );  
    }  
}  
  
運行結果：  
Thread[Thread-2 , 5 ,main] RUNNING.  
Thread[Thread-0 , 5 ,main] RUNNING.  
Thread[Thread-1 , 5 ,main] RUNNING.  
Thread[Thread-4 , 5 ,main] RUNNING.  
Thread[Thread-3 , 5 ,main] RUNNING.  
Over 

CyclicBarrier使用詳解

Java代碼  

import  java.util.Random;  
import  java.util.concurrent.CyclicBarrier;  
  
/** */ /**  
 * CyclicBarrier類似於CountDownLatch也是個計數器，  
 * 不同的是CyclicBarrier數的是調用了CyclicBarrier.await()進入等待的線程數，  
 * 當 等待的 線程數達到了CyclicBarrier初始時規定的數目時，所有進入等待狀態的線程被喚醒並繼續。  
 * CyclicBarrier就象它名字的意思一樣，可看成是個障礙，  
 * 所有的線程必須到齊後才能一起通過這個障礙。  
 * CyclicBarrier初始時還可帶一個Runnable的參數，  
 * 此Runnable任務在CyclicBarrier的 等待的線 數目達到 初始時規定的數目 後，所有其它線程被喚醒前被執行。  
 */   
public   class  CyclicBarrierTest {  
  
    public   static   class  ComponentThread  implements  Runnable {  
        CyclicBarrier barrier;// 計數器   
        int  ID;     // 組件標識   
        int [] array;     // 數據數組   
  
        // 構造方法   
        public  ComponentThread(CyclicBarrier barrier,  int [] array,  int  ID) {  
            this .barrier = barrier;  
            this .ID = ID;  
            this .array = array;  
        }  
  
        public   void  run() {  
            try  {  
                array[ID] = new  Random().nextInt( 100 );  
                System.out.println("Component "  + ID +  " generates: "  + array[ID]);  
                // 在這裏等待Barrier處   
                System.out.println("Component "  + ID +  " sleep" );  
                barrier.await();  
                System.out.println("Component "  + ID +  " awaked" );  
                // 計算數據數組中的當前值和後續值   
                int  result = array[ID] + array[ID +  1 ];  
                System.out.println("Component "  + ID +  " result: "  + result);  
            } catch  (Exception ex) {  
            }  
        }  
    }  
    /** */ /**  
     * 測試CyclicBarrier的用法  
     */   
    public   static   void  testCyclicBarrier() {  
        final   int [] array =  new   int [ 3 ];  
        CyclicBarrier barrier = new  CyclicBarrier( 2 ,  new  Runnable() {  
            // 在所有線程都到達Barrier時執行   
            public   void  run() {  
                System.out.println("testCyclicBarrier run" );  
                array[2 ] = array[ 0 ] + array[ 1 ];  
            }  
        });  
  
        // 啓動線程   
        new  Thread( new  ComponentThread(barrier, array,  0 )).start();  
        new  Thread( new  ComponentThread(barrier, array,  1 )).start();  
    }  
  
    public   static   void  main(String[] args) {  
        CyclicBarrierTest.testCyclicBarrier();  
    }  
}  

說明：在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()...)裏面的方法， 執行完裏面的方法後，等待的兩個線程再次被喚醒，繼續各自執行線程後面的語句。