java并发：Thread中的join方法

join()方法用于等待调用该方法的线程完成执行。当一个线程调用另一个线程的join()方法时，它会暂停自己的执行，直到被调用的线程完成执行才会继续执行。

join()方法特点：

1. 等待线程完成：调用join()方法的线程会等待被调用的线程完成执行。这在需要等待其他线程完成某个任务后再继续执行的情况下非常有用。

2. 同步操作：通过join()方法，可以实现线程的同步操作。主线程可以调用子线程的join()方法，确保子线程在完成后再继续执行主线程的后续操作。

3. 协调线程顺序：通过多次调用join()方法，可以协调多个线程的执行顺序，确保它们按照特定的顺序执行。

4. 异常处理：如果被调用的线程抛出了未捕获的异常，调用它的线程可以通过捕获该异常来处理或做出相应的操作。

 实例1

三个线程T1,T2,T3, 如何保证顺序执行？

 

可以用线程类的 join() 方法在一个线程中启动另一 个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3 调 用T2 ， T2 调用 T1) ，这样 T1 就会先完成而 T3 最后完成。 实际上先启动三个线程中哪一个都行， 因为在每个线程的run 方法中用 join 方法限定了三个线程的 执行顺序。

public class JoinTest {
    // 1.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行
    public static void main(String[] args) {
        final Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t1");
            }
        });
        final Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 引用t1线程，等待t1线程执行完
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2");
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 引用t2线程，等待t2线程执行完
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t3");
            }
        });
        t3.start();//这里三个线程的启动顺序可以任意，大家可以试下！
        t2.start();
        t1.start();
    }
}

实例2

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

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

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

        thread1.join(); // 主线程等待thread1执行完成
        thread2.join(); // 主线程等待thread2执行完成

        System.out.println("All threads completed");
    }
}

主线程启动了两个子线程 thread1 和 thread2，然后通过调用它们的join()方法来等待它们的执行完成。最后，主线程输出 "All threads completed"。通过使用join()方法，可以保证在主线程继续执行之前，thread1 和 thread2 的任务都已经完成。