多线程中Thread的join方法

多线程中Thread的join方法

join简介

join方法是Thread类中的一个方法，该方法的定义是等待该线程执行直到终止。其实就说join方法将挂起调用线程的执行，直到被调用的对象完成它的执行。

join实例（以一道面试题为例）

现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完之后执行，T3在T2执行完后执行？这个问题是网上很热门的面试题（这里除了join还有很多方法能够实现，只是使用join是最简单的方案），下面是实现的代码：

/**
 * @author wcc
 * @date 2021/8/21 20:46
 * 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
 */
public class JoinDemo {

    public static void main(String[] args) {
        //初始化线程1，由于后续有匿名内部类调用这个局部变量，需要用final修饰
        //这里不用final修饰也不会报错的原因 是因为jdk1.8对其进行了优化
        /*
        在局部变量没有重新赋值的情况下，它默认局部变量为final类型，认为你只是忘记了加final声明了而已。
        如果你重新给局部变量改变了值或者引用，那就无法默认为final了
         */
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t1 is running...");
            }
        });

        //初始化线程二
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("t2 is running...");
                }
            }
        });

        //初始化线程三
        Thread t3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("t3 is running...");
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }

}

输出结果：

t1 is running...
t2 is running...
t3 is running...

结果分析：

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

join方法源码解析

	/**
     * 等待该线程终止的时间最长为millis毫秒，超时时间为0意味着要一直等下去
     * @param millis 以毫秒为单位的等待时间
     * @throws InterruptedException
     */
    public final synchronized void join(long millis)
    throws InterruptedException {
        //获取启动的时间戳，用于计算当前时间
        long base = System.currentTimeMillis();
        //当前时间
        long now = 0;

        if (millis < 0) { //等待时间不能小于0 否则抛出IllegalArgumentException异常终止程序
            throw new IllegalArgumentException("timeout value is negative");
        }

		//判断是否携带阻塞的超时时间，等于0则表示没有设置超时时间
        //如果超时时间为0 则意味着一直要等待该线程执行完（无限等待）
        if (millis == 0) {
            //需要注意的是，如果当前线程未被启动或者已经终止，则isAlive方法返回false
            //即意味着join方法不会生效
            while (isAlive()) {
                //isAlive()方法：判断当前线程是否处于活动状态
                //活动状态就是线程已经启动并且尚未终止
                wait(0);
            }
        } else { //设置了超时时间
            //需要注意的是，如果当前线程未被启动或者已经终止，则isAlive方法返回false
            //即意味着join方法不会生效
            while (isAlive()) {，
                //计算剩余时间
                long delay = millis - now;
                if (delay <= 0) { //如果剩余等待的时间小于等于0，则终止等待
                    break;
                }
                //等待指定时间
                wait(delay);
                //获取此次循环执行的时间
                now = System.currentTimeMillis() - base;
            }
        }
    }

从源码中可以得知，如果想要join方法正常生效，调用join方法的线程对象必须已经调用了start()方法并且未进入终止状态。

扩展：

从join方法的源码来看，join方法的本质调用的是Object中的wait方法实现线程的阻塞，wait方法的实现原理在后续的文章中在说详细阐述。**但是我们需要知道的是，调用wait方法必须要获取锁，**所以join方法是被synchronized修饰的，synchronized修饰在很多层面相当于synchronized(this)，this就说Thread本身的实例。

有很多人不理解join为什么阻塞的是主线程呢？不理解的原因是阻塞主线程的方法是放在Thread这个实例中的作用，让大家误以为应该阻塞thread线程。实际上主线程会持有thread这个对象的锁，然后调用wait方法去阻塞，而这个方法的调用者是在主线程中的。所以造成主线程阻塞。

第二个问题：为什么Thread线程执行完毕就能够唤醒主线程呢？或者说在什么时候唤醒的呢？

要了解这个问题，我们又得翻jdk源码，但是如果对线程有既定得基本了解得话，通过wait方法阻塞得线程，需要通过notify或者notifyAll()方法来唤醒。所以在线程执行完毕以后会有一个唤醒得操作，只是在虚拟机内部通过调用native方法实现得