Java Thread.join () 方法详细解析

Thread.join() 是 Thread 类的实例方法，核心作用是实现线程间的同步（等待机制）：当一个线程（如主线程）调用另一个目标线程（如子线程）的join()方法时，调用线程会进入阻塞状态，直到目标线程执行完毕（进入 TERMINATED 状态）或等待超时，才会继续执行自身后续代码。

简单说：A.join() 让「当前线程」等「线程 A」执行完，再继续自己的工作。

二、重载方法

Java 提供了 3 个重载的join()方法，满足不同等待需求：

方法签名	功能说明
`void join() throws InterruptedException`	无参重载：无限等待，调用线程会一直阻塞，直到目标线程完全执行终止（不会主动超时）
`void join(long millis) throws InterruptedException`	带毫秒参数：超时等待，调用线程最多阻塞`millis`毫秒（千分之一秒），超时后自动唤醒继续执行
`void join(long millis, int nanos) throws InterruptedException`	带毫秒 + 纳秒参数：高精度超时等待，理论上支持纳秒级精度，但实际受操作系统时钟精度限制（一般无需使用，优先用毫秒重载）

关键说明

join(0) 等价于 join()：表示「无限等待目标线程终止」，并非等待 0 毫秒。
纳秒参数（nanos）取值范围：0-999999，超出该范围会抛出IllegalArgumentException。
所有重载方法均会抛出InterruptedException（受检异常），必须捕获或声明抛出（因为等待中的线程可能被其他线程中断）。

三、工作原理

1. 核心逻辑

当线程T1调用线程T2.join()时，底层执行流程如下：

T1（调用线程）会先判断T2（目标线程）是否还处于存活状态（isAlive()）；
若T2仍存活，T1会调用Object.wait()方法（底层依赖 Object 的等待机制），进入阻塞状态；
当T2执行完毕终止时，JVM 会自动调用T2的notifyAll()方法，唤醒所有等待在T2对象上的线程（即T1）；
若设置了超时时间，T1在等待超时后会自动唤醒，无需T2终止。

2. 与`Thread.sleep()`的核心区别

很多人会混淆join()和sleep()，二者的核心差异在于锁释放和使用场景：

特性	`Thread.join()`	`Thread.sleep(long millis)`
方法类型	实例方法（针对目标线程）	静态方法（针对当前线程）
锁处理	阻塞时会释放当前线程持有的对象锁	阻塞时不释放任何锁资源
等待状态	无参：WAITING；带参：TIMED_WAITING	TIMED_WAITING
唤醒条件	目标线程终止 / 等待超时 / 被中断	时间到达 / 被中断
核心场景	线程间同步（等待其他线程完成）	当前线程暂停指定时间

四、实战示例

示例 1：无参`join()` - 主线程等待子线程完全执行

public class JoinBasicDemo { public static void main(String[] args) { // 定义子线程：模拟耗时任务（打印1-5，每次间隔500ms） Thread subThread = new Thread(() -> { for (int i = 1; i <= 5; i++) { try { Thread.sleep(500); // 模拟任务耗时 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("子线程执行中：i = " + i); } System.out.println("子线程执行完毕！"); }, "子线程-Test"); System.out.println("主线程启动子线程..."); subThread.start(); // 启动子线程 try { System.out.println("主线程开始等待子线程执行完毕..."); subThread.join(); // 主线程阻塞，等待subThread执行完 } catch (InterruptedException e) { e.printStackTrace(); } // 子线程执行完后，主线程才会执行这里 System.out.println("主线程继续执行，程序结束！"); } }

运行结果（顺序固定）

plaintext

主线程启动子线程... 主线程开始等待子线程执行完毕... 子线程执行中：i = 1 子线程执行中：i = 2 子线程执行中：i = 3 子线程执行中：i = 4 子线程执行中：i = 5 子线程执行完毕！ 主线程继续执行，程序结束！

示例 2：带超时`join(long millis)` - 主线程等待超时后继续执行

修改示例 1 中的join()调用，设置超时时间 1500ms（子线程总耗时 2500ms）：

public class JoinTimeoutDemo { public static void main(String[] args) { Thread subThread = new Thread(() -> { for (int i = 1; i <= 5; i++) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("子线程执行中：i = " + i); } System.out.println("子线程执行完毕！"); }, "子线程-Timeout"); System.out.println("主线程启动子线程..."); subThread.start(); try { System.out.println("主线程开始等待子线程（超时1500ms）..."); subThread.join(1500); // 最多等待1500ms } catch (InterruptedException e) { e.printStackTrace(); } // 1500ms后，主线程不再等待，直接执行后续代码 System.out.println("主线程等待超时，继续执行自身逻辑！"); } }

运行结果（主线程超时后提前执行）

plaintext

主线程启动子线程... 主线程开始等待子线程（超时1500ms）... 子线程执行中：i = 1 子线程执行中：i = 2 子线程执行中：i = 3 主线程等待超时，继续执行自身逻辑！ 子线程执行中：i = 4 子线程执行中：i = 5 子线程执行完毕！

示例 3：多个线程`join()` - 串行等待 vs 并行等待

场景 1：串行等待（主线程依次等待多个子线程，子线程串行执行）

public class JoinSerialDemo { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 1; i <= 3; i++) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t1执行中：i = " + i); } }, "线程t1"); Thread t2 = new Thread(() -> { for (int i = 1; i <= 3; i++) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t2执行中：i = " + i); } }, "线程t2"); t1.start(); t1.join(); // 主线程先等t1执行完 t2.start(); t2.join(); // 再等t2执行完 System.out.println("所有子线程执行完毕，主线程结束！"); } }

场景 2：并行等待（主线程同时等待多个已启动的子线程，子线程并行执行）

public class JoinParallelDemo { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 1; i <= 3; i++) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t1执行中：i = " + i); } }, "线程t1"); Thread t2 = new Thread(() -> { for (int i = 1; i <= 3; i++) { try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t2执行中：i = " + i); } }, "线程t2"); // 先同时启动两个子线程 t1.start(); t2.start(); // 主线程同时等待两个子线程（谁先执行完谁先唤醒，最终等待耗时为较慢线程的执行时间） t1.join(); t2.join(); System.out.println("所有子线程执行完毕，主线程结束！"); } }

五、关键注意事项（避坑指南）

异常必须处理：join()抛出的InterruptedException是受检异常，若不捕获 / 声明抛出，编译报错。当调用线程被中断时，会触发该异常并清除中断状态。
join()不改变线程的启动状态：join()仅负责阻塞调用线程，不会自动启动目标线程，必须先调用targetThread.start()，再调用targetThread.join()。
多个线程等待同一个目标线程：若多个线程同时调用同一个目标线程的join()方法，当目标线程终止时，所有等待线程会被 JVM 同时唤醒（底层notifyAll()）。
与锁结合时的释放特性：若调用线程持有某个对象锁，调用join()后会释放该锁（因为底层调用wait()），而sleep()不会释放锁，这是并发编程中的关键差异。

调用对象必须是已启动的线程：若对未启动（NEW 状态）的线程调用join()，方法会直接返回，不会产生阻塞（因为isAlive()返回 false，无需等待）。

Thread t = new Thread(() -> {}); t.join(); // 无阻塞，直接执行后续代码（t未启动）

六、底层源码简化解析（帮助理解）

以下是Thread.join()的核心源码（JDK8），剔除了冗余逻辑，保留核心流程：

// 无参join() 等价于 join(0) 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"); } // millis=0 表示无限等待 if (millis == 0) { // 只要目标线程还存活，调用线程就一直wait while (isAlive()) { wait(0); } } else { // 超时等待逻辑：循环判断，避免虚假唤醒 while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }

源码关键点

join()是synchronized方法：锁对象是目标线程实例（保证线程安全）。
循环判断isAlive()：避免「虚假唤醒」（即使被意外唤醒，若目标线程未终止，仍会继续等待）。
依赖Object.wait()：底层是 Object 的等待 / 唤醒机制，JVM 在目标线程终止时自动调用notifyAll()。

七、总结

核心功能：Thread.join()实现线程同步，让调用线程阻塞等待目标线程终止或超时。
核心重载：无参（无限等待）、join(long millis)（毫秒超时）、join(long millis, int nanos)（高精度超时，极少使用）。
关键差异：与sleep()的核心区别是「释放对象锁」和「使用场景」，join()用于线程同步，sleep()用于当前线程暂停。
避坑要点：先启动目标线程再调用join()、处理InterruptedException、区分串行 / 并行等待。
底层逻辑：基于Object.wait()实现，通过循环判断isAlive()避免虚假唤醒，目标线程终止时由 JVM 唤醒等待线程。