(四)Thread.join的做用和原理

文章簡介

不少人對Thread.join的做用以及實現瞭解得不多，畢竟這個api咱們不多使用。這篇文章仍然會結合使用及原理進行深度分析

內容導航

1. Thread.join的做用
2. Thread.join的實現原理
3. 何時會使用Thread.join

Thread.join的做用

以前有人問過我一個這樣的面試題

Java中如何讓多線程按照本身指定的順序執行？

這個問題最簡單的回答是經過Thread.join來實現，長此以往就讓不少人誤覺得Thread.join是用來保證線程的順序性的。
下面這段代碼演示了Thread.join的做用

public class JoinDemo extends Thread{
    int i;
    Thread previousThread; //上一個線程
    public JoinDemo(Thread previousThread,int i){
        this.previousThread=previousThread;
        this.i=i;
    }
    @Override
    public void run() {
        try {
          //調用上一個線程的join方法，你們能夠本身演示的時候能夠把這行代碼註釋掉
            previousThread.join(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("num:"+i);
    }
    public static void main(String[] args) {
        Thread previousThread=Thread.currentThread();
        for(int i=0;i<10;i++){
            JoinDemo joinDemo=new JoinDemo(previousThread,i);
            joinDemo.start();
            previousThread=joinDemo;
        }
    }
}

上面的代碼，注意 previousThread.join部分，你們能夠把這行代碼註釋之後看看運行效果，在沒有加join的時候運行的結果是不肯定的。加了join之後，運行結果按照遞增的順序展現出來。

thread.join的含義是當前線程須要等待previousThread線程終止以後才從thread.join返回。簡單來講，就是線程沒有執行完以前，會一直阻塞在join方法處。

下面的圖表現了join對於線程的做用

Thread.join的實現原理

線程是如何被阻塞的？又是經過什麼方法喚醒的呢？先來看看Thread.join方法作了什麼事情

public class Thread implements Runnable {
    ...
    public final 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) { //判斷是否攜帶阻塞的超時時間，等於0表示沒有設置超時時間
            while (isAlive()) {//isAlive獲取線程狀態，無線等待直到previousThread線程結束
                wait(0); //調用Object中的wait方法實現線程的阻塞
            }
        } else { //阻塞直到超時
            while (isAlive()) { 
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
    ...

從join方法的源碼來看，join方法的本質調用的是Object中的wait方法實現線程的阻塞，wait方法的實現原理咱們在後續的文章再說詳細闡述。可是咱們須要知道的是，調用wait方法必需要獲取鎖，因此join方法是被synchronized修飾的，synchronized修飾在方法層面至關於synchronized(this),this就是previousThread自己的實例。

有不少人不理解join爲何阻塞的是主線程呢? 不理解的緣由是阻塞主線程的方法是放在previousThread這個實例做用，讓你們誤覺得應該阻塞previousThread線程。實際上主線程會持有previousThread這個對象的鎖，而後調用wait方法去阻塞，而這個方法的調用者是在主線程中的。因此形成主線程阻塞。

第二個問題，爲何previousThread線程執行完畢就可以喚醒住線程呢？或者說是在何時喚醒的？

要了解這個問題，咱們又得翻jdk的源碼，可是若是你們對線程有必定的基本瞭解的話，經過wait方法阻塞的線程，須要經過notify或者notifyall來喚醒。因此在線程執行完畢之後會有一個喚醒的操做，只是咱們不須要關心。
接下來在hotspot的源碼中找到 thread.cpp，看看線程退出之後有沒有作相關的事情來證實咱們的猜測.

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
  assert(this == JavaThread::current(),  "thread consistency check");
  ...
  // Notify waiters on thread object. This has to be done after exit() is called
  // on the thread (if the thread is the last thread in a daemon ThreadGroup the
  // group should have the destroyed bit set before waiters are notified).
  ensure_join(this); 
  assert(!this->has_pending_exception(), "ensure_join should have cleared");
  ...

觀察一下 ensure_join(this)這行代碼上的註釋，喚醒處於等待的線程對象，這個是在線程終止以後作的清理工做，這個方法的定義代碼片斷以下

static void ensure_join(JavaThread* thread) {
  // We do not need to grap the Threads_lock, since we are operating on ourself.
  Handle threadObj(thread, thread->threadObj());
  assert(threadObj.not_null(), "java thread object must exist");
  ObjectLocker lock(threadObj, thread);
  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  thread->clear_pending_exception();
  // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
  // Clear the native thread instance - this makes isAlive return false and allows the join()
  // to complete once we've done the notify_all below
  //這裏是清除native線程，這個操做會致使isAlive()方法返回false
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);//注意這裏
  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  thread->clear_pending_exception();
}

ensure_join方法中，調用 lock.notify_all(thread); 喚醒全部等待thread鎖的線程，意味着調用了join方法被阻塞的主線程會被喚醒； 到目前爲止，咱們基本上對join的原理作了一個比較詳細的分析

總結，Thread.join其實底層是經過wait/notifyall來實現線程的通訊達到線程阻塞的目的；當線程執行結束之後，會觸發兩個事情，第一個是設置native線程對象爲null、第二個是經過notifyall方法，讓等待在previousThread對象鎖上的wait方法被喚醒。

何時會使用Thread.join

在實際應用開發中，咱們不多會使用thread.join。在實際使用過程當中，咱們能夠經過join方法來等待線程執行的結果，其實有點相似future/callable的功能。
咱們經過如下僞代碼來講明join的使用場景

public void joinDemo(){
   //....
   Thread t=new Thread(payService);
   t.start();
   //.... 
   //其餘業務邏輯處理,不須要肯定t線程是否執行完
   insertData();
   //後續的處理，須要依賴t線程的執行結果，能夠在這裏調用join方法等待t線程執行結束
   t.join();
}