Thread类之join方法

最近在看面试题遇到一个问题描述如下:

有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行?

刚看到这个问题时我认为,想让T1->T2->T3依次执行,那就依次定义这样三个线程并按这个顺序启动就可以了嘛!

后来想想是我天真了,其实题目的要求应该是"T2在T1结束后开始执行,T3在T2执行结束后开始执行"

依据测试人员的思想,假如三个线程的执行时间为T3<T2<T1时呢?

再按照我最初的想法,可以三个线程执行顺序就乱套了!

仔细研究后发现这个题目的本质是考察Thread类的join方法的........

下面直接上代码了↓↓↓

public class Test {

    public static void main(String[] args) {
        Thread ta = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程A开始执行.....");
                    Thread.sleep(8000);
                    System.out.println("线程A执行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread tb = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    ta.join();//等待线程A执行结束
                    System.out.println("线程B开始执行.....");
                    Thread.sleep(4000);
                    System.out.println("线程B执行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread tc = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    tb.join();//等待线程B执行结束
                    System.out.println("线程C开始执行.....");
                    Thread.sleep(1000);
                    System.out.println("线程C执行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        ta.start();//线程A开始执行
        tb.start();//线程B开始执行
        tc.start();//线程C开始执行
    }
}

执行结果如下:

Thread类中join方法的解析:

    //方法被synchronized,锁为this,this就是调用join的对象
    public final synchronized void join(long millis)
            throws InterruptedException {
        //获取启动时刻的时间戳
        long base = System.currentTimeMillis();
        //当前时间的初始化
        long now = 0;
        //①参数小于0,非法情况抛出异常
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        //②参数等于0,意为着无限等待
        if (millis == 0) {
            //判断当前线程是否状态,线程若未运行(未启动/已终止),则没有必要继续等待了
            while (isAlive()) {
                wait(0);
            }
        } else {//③参数大于0
            //判断当前线程是否状态,线程若未运行(未启动/已终止),则没有必要继续等待了
            while (isAlive()) {
                //计算出还需等待的时间
                long delay = millis - now;
                //若等待的时间小于0,说明等待时间间隔期已满,结束循环
                if (delay <= 0) {
                    break;
                }
                //执行线程等待
                wait(delay);
                //计算出线程已等待时间
                now = System.currentTimeMillis() - base;
            }
        }
    }

综合分析上面面试题的案例:

①线程tb中执行了ta.join(),那么此时的调用线程为tb,调用对象为ta.

②对象ta充当了同步锁,tb线程会进入等待状态.当ta执行结束后,tb才被唤醒

③同理,线程tc中执行了tb.join(),那么此时的调用线程为tc,调用对象为tb.

④对象tb充当了同步锁,tc线程会进入等待状态.当tb执行结束后,tc才被唤醒