Java Thread.join() 方法深度解析：線程同步的關鍵機制

在實際開發中，異步任務協調是常見場景：主線程啟動子線程執行耗時操作，需等待子線程完成後繼續執行。Thread.join() 正是解決此類「等待線程終止」需求的核心 API。本文將從源碼、使用陷阱、實戰示例三個維度深度解析。

join() 方法族源碼剖析

無參版本：永久等待

public final void join() throws InterruptedException {
    join(0); // 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;
        }
    }
}

關鍵點解讀：

• synchronized 鎖定當前 Thread 實例：確保 wait/notify 機制正確性
• while (isAlive()) 循環：防止虛假喚醒
• 動態計算剩餘時間：delay = millis - now 精確控制超時
• wait(0) 等同永久等待：直到線程結束觸發 notifyAll

納秒級精度版本

public final synchronized void join(long millis, int nanos) throws InterruptedException {
    if (nanos >= 500000 || (nanos != 0 && millis == 0)) millis++; // 納秒進位
    join(millis); // 最终委託毫秒版本
}

三大使用鐵律

1. 只能由 Thread 實例調用：定義在 Thread 類中，非靜態方法
2. 必須處理 InterruptedException：被中斷時拋出，需 try-catch
3. 先 start() 再 join()：未啟動的線程 isAlive() 返回 false，join 直接返回

實戰示例：主子線程協調

public class JoinDemo {
    public static void main(String[] args) {
        ThreadMain main = new ThreadMain();
        main.start(); // 啟動主線程（實為主線程創建的子線程）
    }
}

class ThreadMain extends Thread {
    ThreadSub sub = new ThreadSub();

    public void run() {
        System.out.println("ThreadMain starts!");
        sub.start(); // 啟動子線程
        System.out.println("ThreadMain running before threadsub!");

        try {
            sub.join(); // 關鍵：等待 sub 結束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("ThreadMain running after threadsub!");
        System.out.println("ThreadMain ends!");
    }
}

class ThreadSub extends Thread {
    public void run() {
        System.out.println("ThreadSub starts!");
        for (int i = 0; i < 10; i++) {
            System.out.println("ThreadSub running: " + (i + 1));
        }
        System.out.println("ThreadSub ends!");
    }
}

輸出結果分析

ThreadMain starts!
ThreadMain running before threadsub!
ThreadSub starts!
ThreadSub running: 1
...
ThreadSub running: 10
ThreadSub ends!
ThreadMain running after threadsub!
ThreadMain ends!

輸出清晰驗證了 join() 語義：主線程在 sub.join() 處阻塞，直到子線程 run() 方法執行完畢（即線程死亡）才繼續執行後續代碼。

進階應用場景

• 並行任務聚合：主線程啟動多個工作線程，循環 join() 等待所有完成
• 超時控制：join(5000) 限制最大等待 5 秒，防止死等
• 線程協作管道：生產者-消費者模型中協調處理階段

總結

Thread.join() 基於 wait/notify 機制實現線程等待，是 Java 併發編程中「等待線程終止」的標準方案。掌握其超時語義、中斷處理、啟動順序三大要點，能有效避免併發協調中的常見坑點。