Java多執行緒（八）——join()
一、join()介紹
join() 定義在Thread.java中。
join() 的作用：讓“主執行緒”等待“子執行緒”結束之後才能繼續執行。這句話可能有點晦澀，我們還是通過例子去理解：
// 主執行緒 public class Father extends Thread { public void run() { Son s = new Son(); s.start(); s.join(); ... } } // 子執行緒 public class Son extends Thread { public void run() { ... } }
說明：
上面的有兩個類Father(主執行緒類)和Son(子執行緒類)。因為Son是在Father中建立並啟動的，所以，Father是主執行緒類，Son是子執行緒類。
在Father主執行緒中，通過new Son()新建“子執行緒s”。接著通過s.start()啟動“子執行緒s”，並且呼叫s.join()。在呼叫s.join()之後，Father主執行緒會一直等待，直到“子執行緒s”執行完畢；在“子執行緒s”執行完畢之後，Father主執行緒才能接著執行。 這也就是我們所說的“join()的作用，是讓主執行緒會等待子執行緒結束之後才能繼續執行”！
二、join()原始碼分析
publicfinal void join() throws InterruptedException { join(0); } 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; } } }
說明：
從程式碼中，我們可以發現。當millis==0時，會進入while(isAlive())迴圈；即只要子執行緒是活的，主執行緒就不停的等待。
我們根據上面解釋join()作用時的程式碼來理解join()的用法！
問題：
雖然s.join()被呼叫的地方是發生在“Father主執行緒”中，但是s.join()是通過“子執行緒s”去呼叫的join()。那麼，join()方法中的isAlive()應該是判斷“子執行緒s”是不是Alive狀態；對應的wait(0)也應該是“讓子執行緒s”等待才對。但如果是這樣的話，s.join()的作用怎麼可能是“讓主執行緒等待，直到子執行緒s完成為止”呢，應該是讓"子執行緒等待才對(因為呼叫子執行緒物件s的wait方法嘛)"？
答案：
wait()的作用是讓“當前執行緒”等待，而這裡的“當前執行緒”是指當前在CPU上執行的執行緒。所以，雖然是呼叫子執行緒的wait()方法，但是它是通過“主執行緒”去呼叫的；所以，休眠的是主執行緒，而不是“子執行緒”！
三、join()示例
在理解join()的作用之後，接下來通過示例檢視join()的用法。
package com.demo; public class JoinTest { public static void main(String[] args){ try{ ThreadA t1 = new ThreadA("t1"); // 新建“執行緒t1” t1.start(); // 啟動“執行緒t1” t1.join(); // 將“執行緒t1”加入到“主執行緒main”中，並且“主執行緒main()會等待它的完成” System.out.printf("%s finish\n", Thread.currentThread().getName()); }catch(InterruptedException e){ e.printStackTrace(); } } static class ThreadA extends Thread{ public ThreadA(String name){ super(name); } public void run(){ System.out.printf("%s start\n", this.getName()); // 延時操作 for(int i=0; i <1000000; i++) ; System.out.printf("%s finish\n", this.getName()); } } }
執行結果：
t1 start
t1 finish
main finish結果說明：
執行流程如圖
(01) 在“主執行緒main”中通過 new ThreadA("t1") 新建“執行緒t1”。 接著，通過 t1.start() 啟動“執行緒t1”，並執行t1.join()。
(02) 執行t1.join()之後，“主執行緒main”會進入“阻塞狀態”等待t1執行結束。“子執行緒t1”結束之後，會喚醒“主執行緒main”，“主執行緒”重新獲取cpu執行權，繼續執行。
一、join()的作用
join()是Thread類的一個方法。根據jdk文件的定義：
public final void join()throws InterruptedException: Waits for this thread to die.
join()方法的作用，是等待這個執行緒結束；但顯然，這樣的定義並不清晰。個人認為"Java 7 Concurrency Cookbook"的定義較為清晰：
join() method suspends the execution of the calling thread until the object called finishes its execution.
也就是說，t.join()方法阻塞呼叫此方法的執行緒(calling thread)，直到執行緒t完成，此執行緒再繼續；通常用於在main()主執行緒內，在某些情況下，主執行緒建立並啟動了子執行緒，如果子執行緒中需要進行大量的耗時運算，主執行緒往往將早於子執行緒結束之前結束，如果主執行緒想等待子執行緒執行完畢後，獲得子執行緒中的處理完的某個資料，就要用到join()方法了，即等待其它執行緒完成再結束main()主執行緒。
例子1：
package com.demo.join; public class Test { public static class MyThread extends Thread { @Override public void run() { try { System.out.println("我在子執行緒中睡眠1秒中"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) throws InterruptedException { MyThread myThread =new MyThread(); myThread.start(); myThread.join(); System.out.println("正常情況下肯定是我先執行完，但是加入join後，main主執行緒會等待子執行緒執行完畢後才執行"); } }
輸出結果：
我在子執行緒中睡眠1秒中
正常情況下肯定是我先執行完，但是加入join後，main主執行緒會等待子執行緒執行完畢後才執行例子2：在主執行緒中開啟一個子執行緒，用來計算1至100的和，然後在主執行緒中打印出來。
package com.demo.join; public class JoinDemo { static int result = 0; public static void main(String[] args) { Thread subThread = new Thread() { @Override public void run() { for (int i = 1; i <= 100; i++) { result = result + i; /*模擬耗時操作*/ try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } } } }; subThread.start(); System.out.print("1到100求和結果等於：" + result); } }
程式執行結果：
1到100求和結果等於：0
出錯了。程式執行進入Main()函式後，開啟子執行緒subThread計算求和。此時主執行緒並沒有停止，繼續往下執行。子執行緒subThread執行耗時大約2秒，而主執行緒如出膛子彈迅速往下執行完畢。子執行緒此該還沒有反應過來，主執行緒已經輸出了結果。為了輸出正確的結果，顯而易見，必須讓主執行緒等待子執行緒執行完畢再執行System.out.print。這時，輪到Thread.Join()出場了。 在subThread.start()和System.out.print(result)之間加上：
try { subThread.join(); } catch (InterruptedException e) { e.printStackTrace(); }
程式執行結果：
1到100求和結果等於：5050
結果正確！
join()方法中可以設定值，即等待多久。比如上面如果把subThread.join()改為subThread.join(1000)，就是告訴主執行緒等待子執行緒1秒鐘後再繼續執行。你可以這樣修改後試著執行一下程式，這時程式輸出的應該是0到5050間的一個值。
例子3：
package com.demo.join; public class JoinTest { public static void main(String [] args) throws InterruptedException { ThreadJoinTest t1 = new ThreadJoinTest("小明"); ThreadJoinTest t2 = new ThreadJoinTest("小東"); t1.start(); /**join的意思是使得放棄當前執行緒的執行，並返回對應的執行緒，例如下面程式碼的意思就是： 程式在main執行緒中呼叫t1執行緒的join方法，則main執行緒放棄cpu控制權，並返回t1執行緒繼續執行直到執行緒t1執行完畢 所以結果是t1執行緒執行完後，才到主執行緒執行，相當於在main執行緒中同步t1執行緒，t1執行完了，main執行緒才有執行的機會 */ t1.join(); t2.start(); } }
package com.demo.join; public class ThreadJoinTest extends Thread{ public ThreadJoinTest(String name){ super(name); } @Override public void run(){ for(int i=0;i<1000;i++){ System.out.println(this.getName() + ":" + i); } } }
上面程式結果是先列印完小明執行緒，在列印小東執行緒。
上面註釋也大概說明了join方法的作用：在A執行緒中呼叫了B執行緒的join()方法時，表示只有當B執行緒執行完畢時，A執行緒才能繼續執行，即join方法的主要作用就是同步，它可以使得執行緒之間的並行執行變為序列執行。注意，這裡呼叫的join方法是沒有傳參的，join方法其實也可以傳遞一個引數給它的，具體看下面的簡單例子：
package com.demo.join; public class JoinTest { public static void main(String [] args) throws InterruptedException { ThreadJoinTest t1 = new ThreadJoinTest("小明"); ThreadJoinTest t2 = new ThreadJoinTest("小東"); t1.start(); /**join方法可以傳遞引數，join(10)表示main執行緒會等待t1執行緒10毫秒，10毫秒過去後， * main執行緒和t1執行緒之間執行順序由序列執行變為普通的並行執行 */ t1.join(10); t2.start(); } }
package com.demo.join; public class ThreadJoinTest extends Thread{ public ThreadJoinTest(String name){ super(name); } @Override public void run(){ for(int i=0;i<1000;i++){ System.out.println(this.getName() + ":" + i); } } }
上面程式碼結果是：程式執行前面10毫秒內列印的都是小明執行緒，10毫秒後，小明和小東程式交替列印。
所以，join方法中如果傳入引數，則表示這樣的意思：如果A執行緒中呼叫B執行緒的join(10)，則表示A執行緒會等待B執行緒執行10毫秒，10毫秒過後，A、B執行緒並行執行。需要注意的是，jdk規定，join(0)的意思不是A執行緒等待B執行緒0秒，而是A執行緒等待B執行緒無限時間，直到B執行緒執行完畢，即join(0)等價於join()。
二、join 與 start 呼叫順序問題
上面的討論大概知道了join的作用了，那麼，如果 join在start前呼叫，會出現什麼後果呢？先看下面的測試結果
package com.demo.join; public class JoinTest { public static void main(String [] args) throws InterruptedException { ThreadJoinTest t1 = new ThreadJoinTest("小明"); ThreadJoinTest t2 = new ThreadJoinTest("小東"); /* *join方法可以在start方法前呼叫時，並不能起到同步的作用 */ t1.join(); t1.start(); t2.start(); } }
package com.demo.join; public class ThreadJoinTest extends Thread{ public ThreadJoinTest(String name){ super(name); } @Override public void run(){ for(int i=0;i<1000;i++){ System.out.println(this.getName() + ":" + i); } } }
上面程式碼執行結果是：小明和小東執行緒交替列印。
所以得到以下結論：join方法必須線上程start方法呼叫之後呼叫才有意義。這個也很容易理解：如果一個執行緒都沒有start，那它也就無法同步了。
三、主執行緒等待多個子執行緒的情況
要想主執行緒main等待若干執行緒結束之後再執行，需要先呼叫各個子執行緒的start()方法，在所有執行緒的start()方法執行完之後，再執行所有子執行緒的join()方法。若依次執行每個執行緒的start()和join()方法，則各個執行緒之間是同步的。舉例如下：
package com.demo.join; public class Test1 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("1 over"); } }); Thread t2 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("2 over"); } }); Thread t3 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("3 over"); } }); try { t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("都結束了"); } }
執行結果：
2 over 1 over 3 over 都結束了
從結果中可以看到三個子執行緒能夠併發執行。若想三個子執行緒會順序同步的執行，需要改變join呼叫位置。
package com.demo.join; public class Test1 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("1 over"); } }); Thread t2 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("2 over"); } }); Thread t3 = new Thread(new Runnable(){ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("3 over"); } }); try { t1.start(); t1.join(); t2.start(); t2.join(); t3.start(); t3.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("都結束了"); } }
執行結果：
1 over 2 over 3 over 都結束了
從結果中可以看出，在多個子執行緒的情況下，若依次執行每個執行緒的start()和join()方法，則各個執行緒之間是同步的。
例子2：在主執行緒中建立了100個子執行緒，每個子執行緒使靜態變數n增加10，如果在這100個子執行緒都執行完後輸出n，這個n值應該是1000。
（1）先來看不加join()的情況：
package com.demo.join; public class JoinThread extends Thread{ public static volatile int n = 0; public void run(){ for (int i = 0; i < 10; i++) { try{ // 為了使執行結果更隨機，延遲3毫秒 sleep(3); n++; } catch (Exception e){ } } } public static void main(String[] args) throws Exception{ Thread threads[] = new Thread[100]; for (int i = 0; i < threads.length; i++) { // 建立100個執行緒 threads[i] = new JoinThread(); } for (int i = 0; i < threads.length; i++) { // 執行剛才建立的100個執行緒 threads[i].start(); } System.out.println("n=" + JoinThread.n); } }
執行結果：
n=71
這個執行結果可能在不同的執行環境下有一些差異，但一般n不會等於1000。從上面的結果可以肯定，這100個執行緒並未都執行完就將n輸出了。
（2）先呼叫各個子執行緒的start()方法，再執行所有子執行緒的join()方法。
package com.demo.join; public class JoinThread extends Thread{ public static volatile int n = 0; public void run(){ for (int i = 0; i < 10; i++) { try{ // 為了使執行結果更隨機，延遲3毫秒 sleep(3); n++; //System.out.println(Thread.currentThread().getName()+"-------"+n); } catch (InterruptedException e){ e.printStackTrace(); } } } public static void main(String[] args) throws Exception{ Thread threads[] = new Thread[100]; for (int i = 0; i < threads.length; i++) { // 建立100個執行緒 threads[i] = new