多线程 | join方法

1. 作用

在 Java 多线程中，join方法用于等待一个线程执行完毕。当一个线程调用另一个线程的join方法时，当前线程会进入等待状态，直到被调用的线程执行完毕。这使得开发者可以控制线程的执行顺序，确保某些关键线程在其他线程之前完成执行。

2. 用法

基本用法：

• join()：无参数的join方法会使当前线程等待调用该方法的线程执行完毕。
• join(long millis)：这个版本的join方法允许指定一个等待的时间（以毫秒为单位）。如果在指定时间内被调用的线程没有执行完毕，当前线程将不再等待，继续执行后续代码。
• join(long millis, int nanos)：这个版本更加精确，可以指定等待的时间和纳秒数。

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("Thread 1 completed.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("Thread 2 completed.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();

        // 等待 thread1 执行完毕
        thread1.join();
        System.out.println("Thread 1 joined.");

        // 等待 thread2 执行完毕
        thread2.join();
        System.out.println("Thread 2 joined.");
    }
}

在上述代码中，首先创建了两个线程thread1和thread2，分别模拟耗时 2 秒和 3 秒的任务。然后启动这两个线程，并使用join方法等待它们执行完毕。在每个线程执行完毕后，会输出相应的消息。

3. 异常

InterruptedException异常：当一个线程在等待另一个线程执行完毕时，如果被中断，会抛出异常，如下代码。
首先启动一个线程thread1，它会睡眠 5 秒钟。主线程等待 2 秒钟后中断thread1，然后调用join方法等待thread1结束。如果thread1在执行过程中被中断，它会捕获InterruptedException异常并打印相应的消息，同时再次设置中断标志。如果主线程在等待thread1结束时被中断，也会捕获InterruptedException异常并打印相应的消息。

public class JoinWithInterruptionExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(5000);
                System.out.println("Thread 1 completed.");
            } catch (InterruptedException e) {
                System.out.println("Thread 1 interrupted.");
                Thread.currentThread().interrupt();
            }
        });

        thread1.start();

        Thread.sleep(2000);

        System.out.println("Interrupting thread 1.");
        thread1.interrupt();

        try {
            thread1.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted while waiting for thread 1.");
            Thread.currentThread().interrupt();
        }
    }
}

InterruptedException异常。在实际应用中，需要正确处理这个异常，以确保程序的稳定性。

死锁风险：如果在使用join方法时不恰当的同步，可能会导致死锁。例如，如果两个线程相互等待对方执行完毕，就会发生死锁。因此，在使用join方法时，需要仔细考虑线程之间的依赖关系，避免死锁的发生。

4. 源码

可以看出，join()方法的底层是利用wait()方法实现的。具体的步骤如下：

1. 检查当前线程是否被中断：
   如果当前线程在调用join方法时已经被中断，那么会抛出InterruptedException异常。这确保了在等待另一个线程完成的过程中，如果当前线程被中断，可以及时响应中断信号。
2. 计算等待时间：
   如果没有传入具体的等待时间参数，那么等待时间被设置为Long.MAX_VALUE，表示无限期等待。如果传入了等待时间参数，那么根据参数计算等待的毫秒数和纳秒数。
3. 调用wait方法等待：
   join方法内部实际上是通过调用当前线程（即调用join的线程）的wait方法来实现等待的。这是因为wait方法会使当前线程进入等待状态，直到另一个线程调用notify或notifyAll方法来唤醒它。在join方法中，被等待的线程完成执行时会调用notifyAll方法来唤醒等待的线程。
4. 检查被等待线程的状态：
   在等待的过程中，会不断检查被等待线程的状态。如果被等待线程仍然处于活动状态，那么继续等待；如果被等待线程已经终止，那么退出等待状态。

为什么使用wait方法

1. 实现等待机制：
   wait方法是 Java 中用于线程间通信和等待的机制之一。在join方法中，使用wait方法可以使当前线程进入等待状态，直到被等待的线程完成执行。这样可以实现线程之间的同步，确保在被等待线程执行完毕之前，当前线程不会继续执行。
2. 避免忙等待：
   如果不使用wait方法，实现等待另一个线程完成的功能可能需要使用循环不断检查被等待线程的状态，这种方式被称为忙等待。忙等待会浪费 CPU 资源，因为线程在等待的过程中仍然在不断地检查状态，而没有真正地等待。使用wait方法可以让线程进入等待状态，释放 CPU 资源，直到被唤醒。
3. 与notify/notifyAll配合使用：
   wait方法通常与notify或notifyAll方法配合使用。在join方法中，被等待的线程完成执行时会调用notifyAll方法来唤醒等待的线程。这种机制可以确保等待的线程在被等待线程完成执行后能够及时被唤醒，继续执行后续的代码。

5. 如何实现按照指定顺序执行线程

代码示例如下

public class ThreadOrderWithJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running.");
        });

        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
                System.out.println("Thread 2 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread thread3 = new Thread(() -> {
            try {
                thread2.join();
                System.out.println("Thread 3 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这个示例中，首先创建了三个线程thread1、thread2和thread3。在thread2中，通过调用thread1.join()确保在thread1执行完毕后才开始执行thread2。在thread3中，通过调用thread2.join()确保在thread2执行完毕后才开始执行thread3。这样就实现了按照指定的顺序执行线程。

6. 线程运行状态

未使用join

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+" start");
        ThreadTest t1 = new ThreadTest("A");
        ThreadTest t2 = new ThreadTest("B");

        System.out.println("t1 start");
        t1.start();
        System.out.println("t1 end");

        System.out.println("t2 start");
        t2.start();
        System.out.println("t2 end");
        System.out.println(Thread.currentThread().getName()+" end");
    }
}

class ThreadTest extends Thread {
    private String name;
    public ThreadTest(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for(int i =1;i<=3;i++){
            System.out.println(name +"-"+i);
            try {
                Thread.sleep(new Random().nextInt(10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//结果
main start
t1 start
t1 end
t2 start
A-1
t2 end
main end
B-1
A-2
B-2
A-3
B-3

使用join

//结果
main start
t1 start
t1 end
A-1
A-2
A-3
t2 start
t2 end
main end
B-1
B-2
B-3