一個Thread.join()面試題的思考

1. 背景

最近參加了一家公司的面試，不知道爲啥如今公司面試都喜歡安排在下午2點，應該是他們剛剛午休結束吧，沒辦法只能犧牲本身的午休時間，好不容易通過一個多小時的地鐵終於到了目標公司，人事的小姑娘直接把我領到會議室給了一個筆試卷子就撤了，那就開始作題目吧。java

2. 題目

第一題是關於線程併發的，直接就讓我犯了迷糊：面試

// 寫出這段程序的最後輸出結果

public class ThreadJoinTest {
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        // 定義兩個鎖對象。
        Object lock1 = new Object();
        Object lock2 = new Object();
        
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                // 開始線程主體以前先獲取鎖對象 'lock1' 。
                synchronized(lock1) {
                    // 打印線程開始執行信息。
                    System.out.println("thread1 start");
                    try {
                        // 休眠一分鐘，模擬耗時任務。
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 獲取鎖對象 'lock2'，注意此時線程仍然持有鎖 'lock1'，
                    // 也就是說線程是在持有鎖'lock1'的前提下嘗試獲取鎖對象'lock2'。
                    synchronized(lock2) {
                        System.out.println("thread1 end");
                    }
                    // 線程釋放鎖對象'lock2'。
                }
                // 線程釋放鎖對象'lock1'。
            }
        };
		
        Thread thread2 = new Thread() {
            @Override
            public void run() {
                // 開始線程主體以前先獲取鎖對象'lock2'。
                synchronized(lock2) {
                    // 打印線程開始執行信息。
                    System.out.println("thread2 start");
                    try {
                        // 休眠一分鐘，模擬耗時任務。
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 在線程持有鎖對象'lock2'的狀況下嘗試獲取鎖對象'lock1'。
                    synchronized(lock1) {
                        System.out.println("thread2 end");
                    }
                    // 釋放鎖對象'lock1'。
                }
                // 釋放鎖對象'lock2'。
            }
        };
        
        // 啓動線程
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        // 主線程休眠兩分鐘，模擬耗時任務。
        Thread.sleep(2000);
        // 打印主線程結束信息。
        System.out.println("main thread end");
    }
}
複製代碼

我看到題目的第一印象覺得考察的線程併發和死鎖問題，本身認爲程序的執行過程以下：bash

首先線程thread1先啓動執行並獲取了鎖對象lock1，這時會直接打印thread1 start,而後休眠了1分鐘來模擬耗時任務；
而後線程thread2也已經啓動並獲取了鎖對象lock2，這時會直接打印thread2 start,而後休眠了1分鐘來模擬耗時任務；
當線程thread1休眠結束準備繼續往下執行，須要獲取鎖對象lock2，因爲這時線程thread2持有了鎖lock2,因此線程thread1因爲沒法獲取鎖對象處於阻塞狀態；
當線程thread2休眠結束準備繼續往下執行，須要獲取鎖對象lock1，因爲這是線程thread1持有了鎖lock1,因此線程thread2因爲沒法獲取鎖對象處於阻塞狀態；
在前面的過程當中，thread1持有lock1等待lock2，與此同時thread2持有lock2等待lock1，明顯處於死鎖狀態，因此這兩個線程誰也沒法繼續向下執行；
因爲thread1和thread2處於死鎖狀態，都沒法繼續向下執行，那主線程就會得到執行的機會，進而打印main thread end。

綜上，我最後給出的結果是:markdown

thread1 start
thread2 start
main thread end
複製代碼

在和麪試官當面交流的時候，特地談到這個題目，面試官說這道題主要考察的是join的用法，顯然我對這個沒有正確的認識，最後給的答案天然也是錯誤的。併發

3. 思考

3.1 用法

既然花了一下午的時間去參加了面試，至少要有一點點的收穫吧，否則豈不是在浪費生命，因此回來仍是稍微查了下Thread.join()的含義和用法，咱們直接來看下源碼裏對這個方法的描述。app

// Thread.java

/** * Waits for this thread to die. * * <p> An invocation of this method behaves in exactly the same * way as the invocation * * <blockquote> * {@linkplain #join(long) join}{@code (0)} * </blockquote> * * @throws 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 void join() throws InterruptedException {
    join(0);
}

複製代碼

源碼裏對這個方法的描述只有簡單的一句話「等待這個線程的消亡」，也就說一個線程在調用另外一個線程的join方法後就要等待這個線程消亡後才能繼續往下執行，至關於把併發的線程在這個時間點變成串行執行序列了。ide

在理解了這點後，再回過頭來看看上面的題目，在thread1和thread2的死鎖等待方面的分析都是正確的，關鍵點在於主線程在這以後是否還能夠繼續往下執行。因爲在主線程中調用了thread1.join()和thread2.join()，就代表主線程必須等待這兩個線程執行完才能繼續執行，但thread1和thread2已經處於死鎖狀態，是不可能消亡的，這也就致使主線程沒法繼續下去了，因此最後的輸出結果應該是：函數

thread1 start
thread2 start
複製代碼

我本身也在回來以後運行過這段代碼，結果和分析的一致，也算弄明白了Thread.join()是咋回事了。oop

3.2 實現原理

在弄明白Thread.join()的用法和含義是否是就圓滿結束了？固然不是，咱們儘量地瞭解其內部的實現原理。學習

簡單來講就是要知道兩個問題：

如何讓當前線程在調用Thread.join()以後中止執行，直到另外一個線程消亡的？
在另外一個線程消亡後，當前線程是如何繼續開始執行的？

3.2.1 如何中止

一切來源於代碼，咱們天然要到代碼去尋找答案，仍是再來看下Thread.join()的聲明和定義：

// Thread.java

/** * Waits for this thread to die. */
public final void join() throws InterruptedException {
    // 直接調用另外一個重載函數。
    join(0);
}
    
/** * Waits at most {@code millis} milliseconds for this thread to * die. A timeout of {@code 0} means to wait forever. * * <p> This implementation uses a loop of {@code this.wait} calls * conditioned on {@code this.isAlive}. As a thread terminates the * {@code this.notifyAll} method is invoked. It is recommended that * applications not use {@code wait}, {@code notify}, or * {@code notifyAll} on {@code Thread} instances. * */
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()) {
            // 等待時間沒有直接使用參數指定的 millis,緣由是爲了保持退出循環的可能。
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            // 當線程還處於存活狀態時，就等待一段時間。
            wait(delay);
            // 更新 now 時間信息，是爲了等待時間結束後，再次進到這個循環時可以因爲 delay <= 0 而直接退出循環。
            now = System.currentTimeMillis() - base;
        }
    }
}
複製代碼

這個函數的代碼量並不大，邏輯也比較容易理解，就是在線程A中調用線程B的join()方法後，這個線程A就會處於對線程B的wait狀態，根據傳入的參數不一樣能夠處於一直等待也能夠只等待一段時間。

3.2.2 如何恢復

既然線程A在調用線程B的join方法後就會處於wait狀態，那線程A又是在什麼時候恢復執行的呢？這裏只介紹不帶參數的join方法，即一直等待的狀況。從join方法的介紹中可知，要等到線程B的消亡，線程A才能恢復，這是如何實現的呢？

// Thread.java

/** * This method is called by the system to give a Thread * a chance to clean up before it actually exits. */
private void exit() {
    if (group != null) {
        // 調用銷燬回調
        group.threadTerminated(this);
        group = null;
    }
    /* Aggressively null out all reference fields: see bug 4006245 */
    target = null;
    /* Speed the release of some of these resources */
    threadLocals = null;
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}
複製代碼

在線程真正退出以前，系統會調用exit方法來進行一些回收操做，從代碼能夠看到除了group.threadTerminated()以外都是一些置空操做，極可能起到恢復做用的邏輯就藏在group.threadTerminated()裏面，這裏的group是ThreadGroup的實例，是線程在初始化的時候建立的，能夠簡單理解爲這個線程屬於這類線程組的。

直接來看ThreadGroup.threadTerminated()的代碼：

/** * Notifies the group that the thread {@code t} has terminated. * * <p> Destroy the group if all of the following conditions are * true: this is a daemon thread group; there are no more alive * or unstarted threads in the group; there are no subgroups in * this thread group. * * @param t * the Thread that has terminated */
void threadTerminated(Thread t) {
    synchronized (this) {
        remove(t);

        if (nthreads == 0) {
            // 喚醒全部的等待線程。
            notifyAll();
        }
        if (daemon && (nthreads == 0) &&
            (nUnstartedThreads == 0) && (ngroups == 0))
        {
            destroy();
        }
    }
}
複製代碼

很明顯，在線程被銷燬的時候會調用notifyAll()來喚醒全部等待線程，因此線程A才能在線程B消亡的時候恢復運行。

4. 拓展

其實Thread裏面除了join()方法，還有一個yield()值得咱們關注，因爲這個方法相對簡單，在這裏只是簡單地提到並不會詳細講解，廢話很少說，仍是直接來看源碼：

/** * A hint to the scheduler that the current thread is willing to yield * its current use of a processor. The scheduler is free to ignore this * hint. * * <p> Yield is a heuristic attempt to improve relative progression * between threads that would otherwise over-utilise a CPU. Its use * should be combined with detailed profiling and benchmarking to * ensure that it actually has the desired effect. * * <p> It is rarely appropriate to use this method. It may be useful * for debugging or testing purposes, where it may help to reproduce * bugs due to race conditions. It may also be useful when designing * concurrency control constructs such as the ones in the * {@link java.util.concurrent.locks} package. */
public static native void yield();
複製代碼

這個方法是個native方法，咱們沒法直接看到它的內部實現，那就看下它的聲明，裏面提到兩點重要信息：

做用：告訴線程調度器當前的線程打算放棄對處理器的使用，至於處理器是否會因爲這個信息進而從新調用線程，要看具體的調度策略；
使用場景：通常是用來進行調試用的，由於這個方法沒法保證當前的線程調用這個方法後，其餘線程必定會獲得處理器，也就沒法用來控制線程之間的執行順序。

直接給出一個簡單的例子：

public class ThreadYieldTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        YieldThread thread1 = new YieldThread("thread_1");
        YieldThread thread2 = new YieldThread("thread_2");
        thread1.start();
        thread2.start();
    }

    private static class YieldThread extends Thread {
        private String name;
        public YieldThread(String name) {
            super(name);
            this.name = name;
        }
        
        @Override
        public void run() {
            for (int i = 0; i < 50; i ++) {
                System.out.println(name + " : " + i);
                if (i == 25) {
                    // 在線程執行到一半的時候，調用 yield 方法嘗試放棄執行。
                    System.out.println(name + ": yield");
                    Thread.yield();
                }
            }
        }
    }
}
複製代碼

有興趣的同窗能夠屢次運行這段程序看看結果，從結果也能夠發現並非每次thread1或者thread2在執行yield後另外一個線程均可以獲取處理器進而開始執行的，正是因爲這個不肯定性，不建議你們在代碼裏用這個方法來控制線程之間的執行。

5. 總結

經過一個簡單的面試題，可以學習到一點知識，對本身也是一種提高，感受本身平時對這些基礎問題的思考太少了，在埋頭解決bug之餘，仍是要注意學習積累知識的。