Java Thread.join()詳解

一、使用方式。

join是Thread類的一個方法，啓動線程後直接調用，例如：

Thread t = new AThread(); t.start(); t.join();

二、爲什麼要用join()方法

在很多情況下，主線程生成並起動了子線程，如果子線程裏要進行大量的耗時的運算，主線程往往將於子線程之前結束，但是如果主線程處理完其他的事務後，需要用到子線程的處理結果，也就是主線程需要等待子線程執行完成之後再結束，這個時候就要用到join()方法了。

三、join方法的作用

在JDk的API裏對於join()方法是：

join

public final void join() throws InterruptedException Waits for this thread to die. Throws: InterruptedException  - if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

即join()的作用是：“等待該線程終止”，這裏需要理解的就是該線程是指的主線程等待子線程的終止。也就是在子線程調用了join()方法後面的代碼，只有等到子線程結束了才能執行。

四、用實例來理解

寫一個簡單的例子來看一下join()的用法：

1.AThread 類

1. BThread類

2. TestDemo 類

   class BThread extends Thread {
       public BThread() {
           super("[BThread] Thread");
       };
       public void run() {
           String threadName = Thread.currentThread().getName();
           System.out.println(threadName + " start.");
           try {
               for (int i = 0; i < 5; i++) {
                   System.out.println(threadName + " loop at " + i);
                   Thread.sleep(1000);
               }
               System.out.println(threadName + " end.");
           } catch (Exception e) {
               System.out.println("Exception from " + threadName + ".run");
           }
       }
   }
   class AThread extends Thread {
       BThread bt;
       public AThread(BThread bt) {
           super("[AThread] Thread");
           this.bt = bt;
       }
       public void run() {
           String threadName = Thread.currentThread().getName();
           System.out.println(threadName + " start.");
           try {
               bt.join();
               System.out.println(threadName + " end.");
           } catch (Exception e) {
               System.out.println("Exception from " + threadName + ".run");
           }
       }
   }
   public class TestDemo {
       public static void main(String[] args) {
           String threadName = Thread.currentThread().getName();
           System.out.println(threadName + " start.");
           BThread bt = new BThread();
           AThread at = new AThread(bt);
           try {
               bt.start();
               Thread.sleep(2000);
               at.start();
               at.join();
           } catch (Exception e) {
               System.out.println("Exception from main");
           }
           System.out.println(threadName + " end!");
       }
   }

   打印結果：

   main start.    //主線程起動，因爲調用了at.join()，要等到at結束了，此線程才能向下執行。 
   [BThread] Thread start. 
   [BThread] Thread loop at 0 
   [BThread] Thread loop at 1 
   [AThread] Thread start.    //線程at啓動，因爲調用bt.join()，等到bt結束了才向下執行。 
   [BThread] Thread loop at 2 
   [BThread] Thread loop at 3 
   [BThread] Thread loop at 4 
   [BThread] Thread end. 
   [AThread] Thread end.    // 線程AThread在bt.join();阻塞處起動，向下繼續執行的結果 
   main end!      //線程AThread結束，此線程在at.join();阻塞處起動，向下繼續執行的結果。

   修改一下代碼:

   public class TestDemo {
       public static void main(String[] args) {
           String threadName = Thread.currentThread().getName();
           System.out.println(threadName + " start.");
           BThread bt = new BThread();
           AThread at = new AThread(bt);
           try {
               bt.start();
               Thread.sleep(2000);
               at.start();
               //at.join(); //在此處註釋掉對join()的調用
           } catch (Exception e) {
               System.out.println("Exception from main");
           }
           System.out.println(threadName + " end!");
       }
   }

   打印結果：

   main start.    // 主線程起動，因爲Thread.sleep(2000)，主線程沒有馬上結束;
   
   [BThread] Thread start.    //線程BThread起動
   [BThread] Thread loop at 0
   [BThread] Thread loop at 1
   main end!   // 在sleep兩秒後主線程結束，AThread執行的bt.join();並不會影響到主線程。
   [AThread] Thread start.    //線程at起動，因爲調用了bt.join()，等到bt結束了，此線程才向下執行。
   [BThread] Thread loop at 2
   [BThread] Thread loop at 3
   [BThread] Thread loop at 4
   [BThread] Thread end.    //線程BThread結束了
   [AThread] Thread end.    // 線程AThread在bt.join();阻塞處起動，向下繼續執行的結果

   五、從源碼看join()方法

   在AThread的run方法裏，執行了bt.join();，進入看一下它的JDK源碼：

   public final void join() throws InterruptedException {
       join(0L);
   }

   然後進入join(0L)方法：

   public final synchronized void join(long l)
       throws InterruptedException
   {
       long l1 = System.currentTimeMillis();
       long l2 = 0L;
       if(l < 0L)
           throw new IllegalArgumentException("timeout value is negative");
       if(l == 0L)
           for(; isAlive(); wait(0L));
       else
           do
           {
               if(!isAlive())
                   break;
               long l3 = l - l2;
               if(l3 <= 0L)
                   break;
               wait(l3);
               l2 = System.currentTimeMillis() - l1;
           } while(true);
   }

   單純從代碼上看： * 如果線程被生成了，但還未被起動，isAlive()將返回false，調用它的join()方法是沒有作用的。將直接繼續向下執行。 * 在AThread類中的run方法中，bt.join()是判斷bt的active狀態，如果bt的isActive()方法返回false，在bt.join(),這一點就不用阻塞了，可以繼續向下進行了。從源碼裏看，wait方法中有參數，也就是不用喚醒誰，只是不再執行wait，向下繼續執行而已。 * 在join()方法中，對於isAlive()和wait()方法的作用對象是個比較讓人困惑的問題：

   isAlive()方法的簽名是：public final native boolean isAlive()，也就是說isAlive()是判斷當前線程的狀態，也就是bt的狀態。

   wait()方法在jdk文檔中的解釋如下：

   Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

   The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

   在這裏，當前線程指的是at。