17.Thread.join的用法和原理

在应用程序中，如果某段程序希望等待前面的线程执行结束后再执行，并发编程里有很多工具可以做，其中Join()就可以 。 join的作用就是让线程的执行结果对后续线程的访问可见。看个例子：

public class JoinTest {
    public static int i = 10;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            i = 30;
            System.out.println("sub thread");
        });
        thread.start();
//        thread.join();
        System.out.println("main " + i);

    }
}

在上面的代码中，如果我们注释掉thread.join()，打印的结果是：

main 10
sub thread

如果取消注释，输出的结果是：

sub thread
main 30

为什么会这样呢？

这就是因为正常情况下，子线程还没执行，main线程已经完了，而加了thread.Join就会让主线程等待，直到子线程的任务都完成之后再继续进行Join()之后的内容。画成结构图就是：

1 经典面试题：多线程按顺序执行

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

public class JoinTest2 {
    public static void main(String[] args) {
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                System.out.println("t1");
            }
        });

        final Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2");
            }
        });

        final Thread t3 = new Thread(new Runnable() {
            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t3");
            }
        });

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

2 执行原理

从上面的分析可以发现，Thread.Join的本质就是通过阻塞唤醒的方式来实现的，底层可能就是使用wait()/notify()方法，实际也确实如此。Join()的核心代码如下：

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {//如果线程是存活状态
            wait(0);//就调用wait()方法阻塞当前线程
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

既然存在wait()方法阻塞，那么必然存在notify()/notifyAll()方法唤醒，而基于Join()方法的原理，就是在线程终止之后触发这个动作。当然可以代码我们看不到，因为这是在JVM里实现的。我们就不再细看了。