关于join官方的解释是 Waits for this thread to die. 也就是等待一个线程结束。可以通过对另一个线程对象调用join()方法可以等待其执行结束，然后才继续往下执行自身线程。

join场景

  1. public class Main {
  3.     public static void main(String[] args) {
  5.         Thread t1 = new Thread(() -> {
  6.             for (int i = 0; i < 100; i++) {
  7.                 System.out.println(Thread.currentThread().getName()+"线程执行..."+i);
  8.             }
  9.         },"T1");
  11.         t1.start();
  13.         for (int i = 0; i < 100; i++) {
  14.             System.out.println(Thread.currentThread().getName()+"线程执行..."+i);
  15.         }
  17.     }
  18. }
  1. ...
  2. T1线程执行...81
  3. T1线程执行...82
  4. main线程执行...50
  5. T1线程执行...83
  6. T1线程执行...84
  7. main线程执行...51
  8. main线程执行...52
  9. T1线程执行...85
  10. T1线程执行...86
  11. main线程执行...53
  12. main线程执行...54
  13. T1线程执行...87
  14. ...

可以看到正常两个线程是交替执行的。如果我们想线程t1执行完再执行main线程呢，这里就需要使用join了：

  1. public class Main {
  3.     public static void main(String[] args) {
  5.         Thread t1 = new Thread(() -> {
  6.             for (int i = 0; i < 100; i++) {
  7.                 System.out.println(Thread.currentThread().getName()+"线程执行..."+i);
  8.             }
  9.         },"T1");
  11.         t1.start();
  13.         // 调用t1的join方法，当前线程等待，等待t1线程执行后再执行当前线程
  14.         try {
  15.             t1.join();
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  20.         for (int i = 0; i < 100; i++) {
  21.             System.out.println(Thread.currentThread().getName()+"线程执行..."+i);
  22.         }
  24.     }
  25. }

执行效果：

  1. ....
  2. T1线程执行...90
  3. T1线程执行...91
  4. T1线程执行...92
  5. T1线程执行...93
  6. T1线程执行...94
  7. T1线程执行...95
  8. T1线程执行...96
  9. T1线程执行...97
  10. T1线程执行...98
  11. T1线程执行...99
  12. main线程执行...0
  13. main线程执行...1
  14. main线程执行...2
  15. main线程执行...3
  16. main线程执行...4
  17. main线程执行...5
  18. main线程执行...6
  19. ....

此时子线程T1执行完之后才执行main线程。

Join方法

join方法还支持几个参数：

Thread的join方法 - 图1

join的使用实例

现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完之后执行，T3在T2执行完后执行？
使用join是最简单的方案，实现的代码如下：

  1. /**
  2.  * @author wcc
  3.  * @date 2021/8/21 20:46
  4.  * 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
  5.  */
  6. public class JoinDemo {
  8.     public static void main(String[] args) {
  10.         Thread t1=new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("t1 is running...");
  14.             }
  15.         });
  17.         //初始化线程二
  18.         Thread t2=new Thread(new Runnable() {
  19.             @Override
  20.             public void run() {
  21.                 try {
  22.                     // 调用t1的join,意味着再t1执行后，才执行此线程
  23.                     t1.join();
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 }finally {
  27.                     System.out.println("t2 is running...");
  28.                 }
  29.             }
  30.         });
  32.         //初始化线程三
  33.         Thread t3=new Thread(new Runnable() {
  34.             @Override
  35.             public void run() {
  36.                 try {
  37.                     // 调用t2的join,意味着再t1执行后，才执行此线程
  38.                     t2.join();
  39.                 } catch (InterruptedException e) {
  40.                     e.printStackTrace();
  41.                 }finally {
  42.                     System.out.println("t3 is running...");
  43.                 }
  44.             }
  45.         });
  47.         t1.start();
  48.         t2.start();
  49.         t3.start();
  50.     }
  52. }

执行结果：

  1. t1 is running...
  2. t2 is running...
  3. t3 is running...

在t2线程中t2本身就是调用线程，所谓的调用线程是指调用了t.join()方法的线程，而被调用的对象指的是调用join方法的线程对象，即t1。_所以这三个线程按照_t1 -> t2 -> t3的顺序执行了。

join原理

  1.     /**
  2.      * 等待该线程终止的时间最长为millis毫秒，超时时间为0意味着要一直等下去
  3.      * @param millis 以毫秒为单位的等待时间
  4.      * @throws InterruptedException
  5.      */
  6.     public final synchronized void join(long millis)
  7.     throws InterruptedException {
  8.         //获取启动的时间戳，用于计算当前时间
  9.         long base = System.currentTimeMillis();
  10.         //当前时间
  11.         long now = 0;
  13.         if (millis < 0) { //等待时间不能小于0 否则抛出IllegalArgumentException异常终止程序
  14.             throw new IllegalArgumentException("timeout value is negative");
  15.         }
  17.         //判断是否携带阻塞的超时时间，等于0则表示没有设置超时时间
  18.         //如果超时时间为0 则意味着一直要等待该线程执行完（无限等待）
  19.         if (millis == 0) {
  20.             //需要注意的是，如果当前线程未被启动或者已经终止，则isAlive方法返回false
  21.             //即意味着join方法不会生效
  22.             while (isAlive()) {
  23.                 //isAlive()方法：判断当前线程是否处于活动状态
  24.                 //活动状态就是线程已经启动并且尚未终止
  25.                 wait(0);
  26.             }
  27.         } else { //设置了超时时间
  28.             //需要注意的是，如果当前线程未被启动或者已经终止，则isAlive方法返回false
  29.             //即意味着join方法不会生效
  30.             while (isAlive()) {，
  31.                 //计算剩余时间
  32.                 long delay = millis - now;
  33.                 if (delay <= 0) { //如果剩余等待的时间小于等于0，则终止等待
  34.                     break;
  35.                 }
  36.                 //等待指定时间
  37.                 wait(delay);
  38.                 //获取此次循环执行的时间
  39.                 now = System.currentTimeMillis() - base;
  40.             }
  41.         }
  42.     }
  1. 如果想要join方法正常生效，调用join方法的线程对象必须已经调用了start()方法并且未进入终止状态。
  2. join方法的本质调用的是Object中的wait方法实现线程的阻塞。
  3. Thread.join其实底层是通过wait/notifyall来实现线程的通信达到线程阻塞的目的；当线程执行结束以后，会触发两个事情，第一个是设置native线程对象为null、第二个是通过notifyall方法，让等待在previousThread对象锁上的wait方法被唤醒。