少年阿賓
          
				
          那些青春的歲月
          
			          		
		
          
	
          

          

          
	
          
		
          
			
				
 
BlogJava ::
首頁 ::
聯系 ::
聚合
 ::
管理

			
			
			
				

	
          
		
          
			
			
			
				 
				500 
				Posts ::
				0 Stories
				::
				135 Comments
				::
				0 Trackbacks
			
		
          
	
          

			          		
		
          
	
          

          


          

          
	
          
	
					

          
			
	
	
          
		在多線程設計中，我猜常常會遇到線程間相互等待以及某個線程等待1個或多個線程的場景，比如多線程精密計算和大量數據處理，這里寫下我自己的體會和理解。 

              
          

              我想應該有很多辦法，如果是簡單的1：1關系，那么可以wait（）和notify（）解決，就像一把鎖和一把鑰匙；如果是1：N關系，這個1就需要關心N的所有狀態了，最笨的辦法是1可以去查看N當前的狀態，輪詢詢問工作是否做完。而好點的辦法是N做完后主動告訴1，然后N就會有2種選擇，要么聽從1的命令，要么繼續干自己其他的活。
          

           
          

              用傳統的方法我想應該是都能實現的，而JDK1.5提供了CyclicBarrier與CountDownLatch來解決了這兩個問題，而她們的區別是：
          

              CyclicBarrier使所有線程相互等待，而CountDownLatch使一個或多個線程等待其他線程。區別類似上面藍色字體，CountDownLatch不會等待其他線程了，只要做完自己的工作就干自己的活去了，也就是run()方法里其他的任務。
          

           
          

          Example：
          

           
          

           
          

          public static void testCountDownLatch() throws InterruptedException{   
            CountDownLatch cdl          =new CountDownLatch(2);   
            ExecutorService exe          =Executors.newFixedThreadPool(2);   
                       class Bow implements  Runnable{   
              CountDownLatch cdl;   
                        public Bow(CountDownLatch cdl){   
                        this.cdl=cdl;    
              }             
                        public void run(){   
               System.out.println(          "The bow is coming");   
               System.out.println(          "kick a bow ");   
                         this.cdl.countDown();   
               System.out.println(          "do other thing");   
               }             
             }             
            exe.execute(          new Bow(cdl));   
            exe.execute(          new Bow(cdl));   
            exe.shutdown();   
            System.out.println(          "Wait");   
              cdl.await();   
              System.out.println(          "End..");   
              
           }             
            
                        public static void main(String[] args) {   
                            try {   
                      Test.testCountDownLatch();   
                  }           catch (InterruptedException e) {   
                  }             
              }            
          

           
          

          輸出的結果為：
          

           
          

          The bow is coming
          kick a bow 
          do other thing
          Wait...
          The bow is coming
          kick a bow 
          do other thing
          End..
          

           
          

          如上所說do other thing不受影響。
          

           
          

          寫了一個CyclicBarrier的例子：
          

           
          

          public static void testCyclicBarrier() throws InterruptedException, BrokenBarrierException{
                  CyclicBarrier barr          =new CyclicBarrier(2+1);
                  
                  ExecutorService exe          =Executors.newFixedThreadPool(2);
                             class Bow implements  Runnable{
                       CyclicBarrier barr;
                                    public Bow(CyclicBarrier barr){
                                    this.barr=barr;    
                          }
                                    public void run(){
                              System.out.println(          "The bow is coming");
                              System.out.println(          "kick a down");
                                        try {
                                  barr.await();
                              }           catch (InterruptedException e) {
                                            // TODO Auto-generated catch block
                                  e.printStackTrace();
                              }           catch (BrokenBarrierException e) {
                                            // TODO Auto-generated catch block
                                  e.printStackTrace();
                              }
                              System.out.println(          "do other thing");
                              }
                      }
                  exe.execute(          new Bow(barr));
                  exe.execute(          new Bow(barr));
                  exe.shutdown();
                  System.out.println(          "Wait");
                  barr.await();
                 System.out.println(          "End..");
              
              }


                        public static void main(String[] args) {
                            try {
                      Test.testCyclicBarrier();
                  }           catch (InterruptedException e) {
                  }
                            catch (BrokenBarrierException e) {
                  }
              }
          

           
          

          輸出結果為：
          

           
          

          Wait...
          The bow is coming
          kick a down
          The bow is coming
          kick a down
          do other thing
          End..
          do other thing
          

           
          

          總結：
          

          我們看到do other thing被阻塞了，直到最后才執行，可見，柵欄和計數器的目完全不同了。向Doug Lea牛人學習：）
          

           









          在網上看到很多人對于CountDownLatch和CyclicBarrier的區別簡單理解為CountDownLatch是一次性的，而CyclicBarrier在調用reset之后還可以繼續使用。那如果只是這么簡單的話，我覺得CyclicBarrier簡單命名為ResetableCountDownLatch好了，顯然不是的。
          我的理解是，要從他們的設計目的去看這兩個類。javadoc里面的描述是這樣的。 
          

          

          CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
          

          CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
          

          可能是我的英語不夠好吧， 我感覺從這個javadoc里面要準確理解他們的差異還是不容易的。
          我的理解是
          

          CountDownLatch : 一個線程(或者多個)， 等待另外N個線程完成某個事情之后才能執行。   CyclicBarrier        : N個線程相互等待，任何一個線程完成之前，所有的線程都必須等待。
          這樣應該就清楚一點了，對于CountDownLatch來說，重點是那個“一個線程”, 是它在等待， 而另外那N的線程在把“某個事情”做完之后可以繼續等待，可以終止。而對于CyclicBarrier來說，重點是那N個線程，他們之間任何一個沒有完成，所有的線程都必須等待。
          



          

          CountDownLatch 是計數器, 線程完成一個就記一個, 就像 報數一樣, 只不過是遞減的.
          而CyclicBarrier更像一個水閘, 線程執行就想水流, 在水閘處都會堵住, 等到水滿(線程到齊)了, 才開始泄流.
          
	
          
	
	
          
		posted on 2013-04-28 15:37 abin 閱讀(457) 評論(0)  編輯  收藏  所屬分類: JavaMultithread 
	
          

          







          
	    
    




          








          

				

          

          




    







          
        
	




主站蜘蛛池模板：
前郭尔|
仁布县|
东方市|
崇文区|
出国|
松滋市|
信丰县|
准格尔旗|
孝昌县|
南雄市|
嘉黎县|
鄂伦春自治旗|
鄂托克旗|
武宁县|
鸡西市|
巴马|
江川县|
三台县|
万载县|
镶黄旗|
富蕴县|
潼南县|
梅州市|
讷河市|
赤水市|
赣州市|
鲜城|
文昌市|
玉田县|
万安县|
汶川县|
察隅县|
根河市|
荣昌县|
罗平县|
阿克苏市|
霍林郭勒市|
南宁市|
从江县|
资阳市|
安仁县|