新的起點 新的開始

          快樂生活 !

          深入淺出Java多線程(1)-方法 join

              對于Java開發人員,多線程應該是必須熟練應用的知識點,特別是開發基于Java語言的產品。本文將深入淺出的表述Java多線程的知識點,在后續的系列里將側重于Java5由Doug Lea教授提供的Concurrent并行包的設計思想以及具體實現與應用。
              如何才能深入淺出呢,我的理解是帶著問題,而不是泛泛的看。所以該系列基本以解決問題為主,當然我也非常希望讀者能夠提出更好的解決問題的方案以及提出更多的問題。由于水平有限,如果有什么錯誤之處,請大家提出,共同討論,總之,我希望通過該系列我們能夠深入理解Java多線程來解決我們實際開發的問題。
              作為開發人員,我想沒有必要討論多線程的基礎知識,比如什么是線程? 如何創建等 ,這些知識點是可以通過書本和Google獲得的。本系列主要是如何理深入解多線程來幫助我們平時的開發,比如線程池如何實現? 如何應用鎖等。 

          (1)方法Join是干啥用的? 簡單回答,同步,如何同步? 怎么實現的? 下面將逐個回答。
              自從接觸Java多線程,一直對Join理解不了。JDK是這樣說的:
          Thread (Java Platform SE 6)    join
              public final void join(long millis)throws InterruptedException
              Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.
           大家能理解嗎? 字面意思是等待一段時間直到這個線程死亡,我的疑問是那個線程,是它本身的線程還是調用它的線程的,上代碼: 
          package concurrentstudy;
          /**
           *
           * 
          @author vma
           
          */
          public class JoinTest {
              
          public static void main(String[] args) {
                  Thread t 
          = new Thread(new RunnableImpl());
                  t.start();
                  
          try {
                      t.join(
          1000);
                      System.out.println(
          "joinFinish");
                  } 
          catch (InterruptedException e) {
                      
          // TODO Auto-generated catch block
                      e.printStackTrace();
               
                  }
              }
          }
          class RunnableImpl implements Runnable {

              @Override
              
          public void run() {
                  
          try {
                      System.out.println(
          "Begin sleep");
                      Thread.sleep(
          1000);
                     System.out.println(
          "End sleep");
                  } 
          catch (InterruptedException e) {
                      e.printStackTrace();
                  }

              }
          }
          結果是:
          Begin sleep
          End sleep
          joinFinish
          明白了吧,當main線程調用t.join時,main線程等待t線程,等待時間是1000,如果t線程Sleep 2000呢
           public void run() {
                  
          try {
                      System.out.println(
          "Begin sleep");
                      // Thread.sleep(
          1000);
                      Thread.sleep(2000);
                     System.out.println("End sleep");
                  } 
          catch (InterruptedException e) {
                      e.printStackTrace();
                  }

              }

          結果是:
          Begin sleep
          joinFinish
          End sleep
          也就是說main線程只等1000毫秒,不管T什么時候結束,如果是t.join()呢, 看代碼:  
           public final void join() throws InterruptedException {
              join(0);
              }
          就是說如果是t.join() = t.join(0) 0 JDK這樣說的 A timeout of 0 means to wait forever 字面意思是永遠等待,是這樣嗎?
          其實是等到t結束后。
          這個是怎么實現的嗎? 看JDK代碼:
              /**
               * Waits at most <code>millis</code> milliseconds for this thread to 
               * die. A timeout of <code>0</code> means to wait forever. 
               *
               * 
          @param      millis   the time to wait in milliseconds.
               * 
          @exception  InterruptedException if any thread has interrupted
               *             the current thread.  The <i>interrupted status</i> of the
               *             current thread is cleared when this exception is thrown.
               
          */
              
          public final synchronized void join(long millis) 
              
          throws InterruptedException {
              
          long base = System.currentTimeMillis();
              
          long now = 0;

              
          if (millis < 0) {
                      
          throw new IllegalArgumentException("timeout value is negative");
              }

              
          if (millis == 0) {
                  
          while (isAlive()) {
                  wait(
          0);
                  }
              } 
          else {
                  
          while (isAlive()) {
                  
          long delay = millis - now;
                  
          if (delay <= 0) {
                      
          break;
                  }
                  wait(delay);
                  now 
          = System.currentTimeMillis() - base;
                  }
              }
              }
          其實Join方法實現是通過wait(小提示:Object 提供的方法)。 當main線程調用t.join時候,main線程會獲得線程對象t的鎖(wait 意味著拿到該對象的鎖),調用該對象的wait(等待時間),直到該對象喚醒main線程,比如退出后。

          這就意味著main 線程調用t.join時,必須能夠拿到線程t對象的鎖,如果拿不到它是無法wait的,剛開的例子t.join(1000)不是說明了main線程等待1秒,如果在它等待之前,其他線程獲取了t對象的鎖,它等待時間可不就是1毫秒了。上代碼介紹:
          /*
           * To change this template, choose Tools | Templates
           * and open the template in the editor.
           
          */
          package concurrentstudy;
          /**
           *
           * 
          @author vma
           
          */
          public class JoinTest {
              
          public static void main(String[] args) {
                  Thread t 
          = new Thread(new RunnableImpl());
                 
          new ThreadTest(t).start();
                  t.start();
                  
          try {
                      t.join();
                      System.out.println(
          "joinFinish");
                  } 
          catch (InterruptedException e) {
                      
          // TODO Auto-generated catch block
                      e.printStackTrace();
               
                  }
              }
          }
          class ThreadTest extends Thread {

              Thread thread;

              
          public ThreadTest(Thread thread) {
                  
          this.thread = thread;
              }

              @Override
              
          public void run() {
                  holdThreadLock();
              }

              
          public void holdThreadLock() {
                  
          synchronized (thread) {
                      System.out.println(
          "getObjectLock");
                      
          try {
                          Thread.sleep(
          9000);

                      } 
          catch (InterruptedException ex) {
                       ex.printStackTrace();
                      }
                      System.out.println(
          "ReleaseObjectLock");
                  }

              }
          }

          class RunnableImpl implements Runnable {

              @Override
              
          public void run() {
                  
          try {
                      System.out.println(
          "Begin sleep");
                      Thread.sleep(
          2000);
                     System.out.println(
          "End sleep");
                  } 
          catch (InterruptedException e) {
                      e.printStackTrace();
                  }


              }
          }
          在main方法中 通過new ThreadTest(t).start();實例化ThreadTest 線程對象, 它在holdThreadLock()方法中,通過 synchronized (thread),獲取線程對象t的鎖,并Sleep(9000)后釋放,這就意味著,即使
          main方法t.join(1000),等待一秒鐘,它必須等待ThreadTest 線程釋放t鎖后才能進入wait方法中,它實際等待時間是9000+1000 MS
          運行結果是:
          getObjectLock
          Begin sleep
          End sleep
          ReleaseObjectLock
          joinFinish

          小結:
          本節主要深入淺出join及JDK中的實現。
          在下一節中,我們將要討論SWing 中的事件方法線程來解決一個網友問到的問題:
          如何控制Swing程序在單機只有一個實例,也就是不能運行第二個Main方法。





             

          posted on 2008-08-23 23:25 advincenting 閱讀(27498) 評論(13)  編輯  收藏

          評論

          # re: 深入淺出Java多線程(1)-方法 join 2008-09-04 20:46 Brian

          學習了,我一直知道join方法的用法,但從沒想法它的實現。受益啊!  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2008-09-08 23:04 Xsource

          明白了····
          謝謝  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2009-02-24 22:51 小石~~

          好文章 不愧是深入淺出 拜讀  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2009-04-09 15:59 Adams

          bu cuo de   回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2009-04-21 15:45 陌生人

          看了你的文章.我測試了下,發現你最后一個例子中,“main方法t.join(1000),等待一秒鐘,它必須等待ThreadTest 線程釋放t鎖后才能進入wait方法中,它實際等待時間是9000+1000 MS” ,它并不是如你寫的這樣,而是ReleaseObjectLock 和joinFinish幾乎一起出現的。 ...


            回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2009-04-21 16:28 陌生人

          我做了個測試:public static void main(String[] args) {
          Thread t = new Thread(new RunnableImpl());
          new ThreadTest(t).start();
          // new ThreadTest(t).start();
          t.start();
          try {
          System.out.println("joinBegin?");
          t.join(50000);
          System.out.println("joinFinish");
          //t.start();
          } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();

          }
          }
          當只有1個new ThreadTest(t).start();的時候,不管你 t.join(50000);里面寫多少,都是一起出現最后結果ReleaseObjectLock,joinFinish。但是當你寫了2個new ThreadTest(t).start(); 這個t.join(50000);里面數字就有關系了,它影響到了joinFinish打印的順序,但是不管你怎么寫,它都是和其中一個ReleaseObjectLock 一起出現..呵呵...希望我才現在回復這個還不嫌晚..  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join[未登錄] 2011-05-26 16:49 Michael

          寫得好,學習了  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2011-08-24 18:14 Scott Fan

          博主啊,你最后這不把我們往坑里帶嘛··

          你看啊,
          Thread的public final synchronized void join(long millis) 方法中
          有這么一個分支:
          if (millis == 0) {
          while (isAlive()) {
          wait(0);
          }
          } else {
          while (isAlive()) // 大家注意這句啊!!
          {
          long delay = millis - now;
          if (delay <= 0) {
          break;
          }
          wait(delay);
          now = System.currentTimeMillis() - base;
          }
          }

          走到 while (isAlive()) 這個循環的時候,線程對象的isAlive()是false啊,所以直接就返回了,
          不會像你說的似的,9000+1000毫秒。

          大家看的時候別往坑里跳啊。  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2012-02-26 23:34 路人甲

          哥們你這篇深入淺出寫得...最后一個程序這毛病多了去了..新手不要往坑里跳....jion的JDK很有參考意義 最后一個程序作為捉蟲程序(邏輯錯誤) 很有價值。。  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join 2012-02-27 00:11 路人甲

          關于最后一個程序,按照作者所寫程序,線程間的運行狀況如下所述:
          首先啟動ThreadTest,對t加鎖(注意,加鎖的是t的代碼塊,此處對t加鎖導致main不能獲得t的鎖,所以t.jion無法執行,但是不影響t線程本身start),然后sleep ,接著t.start(),t sleep 2秒。之后程序無事可做,再7秒之后,ThreatTest線程結束,鎖釋放。main獲得t的鎖,此時t線程已經不是alive。所以立刻輸出jionFinish。在作者的程序中,t.jion相當于將main的線程blocked.若想達到作者最后一句所說的jion 9000+1000毫秒,則在ThreadTest釋放鎖之后,t線程應該處于alive狀態。所以講RunnableImpl中的sleep時間設置為大于10000,則實際等待時間為9000+1000毫秒。但是此時的輸出順序發生變化,為:
          getObjectLock
          Begin sleep
          ReleaseObjectLock
          jionFinish
          End sleep
          希望上述解釋能夠讓大家走出作者的坑。。。另,我把這篇博文轉載到我的blog里面進行更正了  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join[未登錄] 2012-11-06 15:45 test

          最后一個運行了一下,怎么也只有9秒啊?
          Tue Nov 06 15:44:22 CST 2012getObjectLock
          Tue Nov 06 15:44:22 CST 2012Begin sleep
          Tue Nov 06 15:44:24 CST 2012End sleep
          Tue Nov 06 15:44:31 CST 2012ReleaseObjectLock
          Tue Nov 06 15:44:31 CST 2012joinFinish  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join[未登錄] 2013-04-10 14:59 eason

          @路人甲
          精彩,了解了  回復  更多評論   

          # re: 深入淺出Java多線程(1)-方法 join[未登錄] 2013-06-21 14:51

          Begin sleep
          joinFinish
          End sleep
          我的怎么不一樣呀  回復  更多評論   


          只有注冊用戶登錄后才能發表評論。


          網站導航:
          博客園   IT新聞   Chat2DB   C++博客   博問  
           

          公告

          Locations of visitors to this pageBlogJava
        1. 首頁
        2. 新隨筆
        3. 聯系
        4. 聚合
        5. 管理
        6. <2008年8月>
          272829303112
          3456789
          10111213141516
          17181920212223
          24252627282930
          31123456

          統計

          常用鏈接

          留言簿(13)

          隨筆分類(71)

          隨筆檔案(179)

          文章檔案(13)

          新聞分類

          IT人的英語學習網站

          JAVA站點

          優秀個人博客鏈接

          官網學習站點

          生活工作站點

          最新隨筆

          搜索

          積分與排名

          最新評論

          閱讀排行榜

          評論排行榜

          主站蜘蛛池模板: 五河县| 龙岩市| 黄山市| 营口市| 长海县| 黄大仙区| 修武县| 温宿县| 甘泉县| 聊城市| 衡东县| 万年县| 金坛市| 双江| 荔波县| 长垣县| 馆陶县| 麟游县| 盐城市| 韶山市| 岳普湖县| 义马市| 马山县| 吉林省| 安庆市| 遂溪县| 汉沽区| 鞍山市| 富裕县| 三亚市| 固原市| 宽甸| 澄城县| 舟曲县| 尉犁县| 海丰县| 栾川县| 禹州市| 尚义县| 泾阳县| 富裕县|