join 方法的作用是什么？其实现原理是怎样的？

参考回答

join() 方法的作用：
join() 是一个线程同步方法，用于让当前线程等待另一个线程执行完成后再继续执行。它通常用于在线程之间建立顺序关系，确保某些任务的执行顺序符合逻辑。

例如：

• 主线程调用某子线程的 join() 方法，主线程会阻塞，直到子线程执行完毕。

关键点：

1. join() 是线程同步的一种方式，解决了线程之间的执行顺序问题。
2. join() 可以有超时时间（如 join(long millis)），主线程只阻塞指定时间。

详细讲解与拓展

1. 使用示例

以下代码展示了 join() 的基本用法：

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running...");
            try {
                Thread.sleep(2000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread has finished.");
        });

        thread.start();
        System.out.println("Waiting for the thread to complete...");
        thread.join(); // 主线程等待子线程完成
        System.out.println("Main thread resumes.");
    }
}

输出示例：

Waiting for the thread to complete...
Thread is running...
Thread has finished.
Main thread resumes.

2. join() 的实现原理

join() 的底层依赖于 Object 类的 wait() 方法，通过线程间的通信机制实现线程的同步。

实现源码（JDK 8 示例）

以下是 join() 方法的部分实现：

public final void join(long millis) throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    synchronized (this) {
        long base = System.currentTimeMillis();
        long now = 0;
        while (isAlive()) { // 判断线程是否存活
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay); // 当前线程进入等待状态
            now = System.currentTimeMillis() - base;
        }
    }
}

主要逻辑：

1. join() 方法会先检查调用线程是否存活（isAlive()）。
2. 如果存活，当前线程会调用 wait() 方法，进入阻塞状态。
3. 当被等待的线程执行完成后，会调用 notifyAll() 方法唤醒等待线程。

关键点：

• isAlive()：判断线程是否存活。
• wait() 和 notifyAll()：通过同步锁配合，主线程进入等待状态，而被等待的线程执行完后会自动唤醒主线程。

3. 带超时的 join(long millis)

带超时的 join() 方法会阻塞当前线程指定的时间。如果等待线程在超时前完成，主线程立即继续执行；否则，在超时时间到达时恢复。

示例：

public class JoinTimeoutExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(3000); // 模拟耗时操作
                System.out.println("Thread has finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();
        System.out.println("Waiting for the thread to complete...");
        thread.join(1000); // 主线程等待最多 1 秒
        System.out.println("Main thread resumes.");
    }
}

输出示例：

Waiting for the thread to complete...
Main thread resumes.
Thread has finished.

4. 常见问题与注意事项

1. 线程终止后调用 join()： 如果线程已经终止，join() 方法会立即返回，不会造成阻塞。
2. join() 与多线程的配合： 如果多个线程调用 join()，它们会顺序等待每个线程执行完成。
3. 中断问题： join() 会抛出 InterruptedException，如果当前线程在等待时被中断，需要显式捕获并处理。

5. 扩展知识：join() 和其他同步方式的对比

6. 总结

• join() 的作用：让当前线程等待指定线程完成再继续执行，解决线程间的执行顺序问题。
• 实现原理：基于 wait() 和 notifyAll()，通过线程间通信机制实现同步。
• 适用场景：适合简单的线程等待场景，比如主线程等待子线程完成任务。

帅地永久会员

打赏 收藏 海报挣佣金 推广链接