printstacktrace方法_多线程中的join()方法，你了解多少？

这里给大家分享一下我的专栏《Java 进阶集中营》，每天都会给大家分享一个最新的java技术资讯，有优秀的技术内容，也欢迎分享在我的专栏里。

JAVA 进阶集中营​zhuanlan.zhihu.com

为什么会突然想到这么一个方法，好像大家工作中不怎么常用，但是在平时的面试中只要涉及到多线程中，大多情况下都会问到这个方法，我们也只是简单的看看面试题说个大概，但是真正的用法大家可能跟我之前一样是比较模糊的。

1、先看一段代码，你觉得下面的代码的输出顺序是什么？

public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> {

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A执行");
        });

        Thread t2 = new Thread(() -> {

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程B执行");
        });

        t1.start();
        t2.start();

        System.out.println("我是主线程");
    }

没错，执行结果确实是大部分人猜测的那样，先是主线程执行，然后线程B执行，最后是线程A。

我们来稍微改一下代码

public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> {

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A执行");
        });

        Thread t2 = new Thread(() -> {

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程B执行");
        });

        t1.start();
        t1.join();
        t2.start();

        System.out.println("我是主线程");
    }

你们来觉得执行顺序会是什么？我们先来看下答案吧！带着问题我们来认识join方法，到底干了什么。

2、join()方法

大白话：就是谁调用这个方法，就让调用此方法的线程进入阻塞状态，等待我执行完毕之后，再往下执行；

那么我们再来看上面那段加了join()的代码，首先开启线程A，紧接着线程A调用了join()方法进入阻塞状态，那么线程必须等待线程A执行结束之后再往下执行，线程A执行完毕，线程B开启，进入睡眠，主线程执行，线程B睡眠结束，执行；

3、真实场景需求

我上周在做一个爬虫项目，大概是这样的，我要开启多条线程同时爬取不同网站的信息，进行处理，然后统一返回给前台，这里面要注意的就是，我们必须等待前面的线程都执行结束，才能返回给前端，那么join()方法就很适合我们的需求。

public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                System.out.println("线程A ： " + i);
            }
        });

        Thread t2 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                System.out.println("线程B ： " + i);
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("爬取结束");
    }

通过这样，我们A、B两条线程开启之后开始执行，等待他们全部执行结束之后，再对结果进行统一处理。如果不适用join()方法我们看看，会是什么情况。

还没等线程执行结束，就已经将结果返回回去了，这样明显不满足我们的需求。

3、注意，join()的位置可不是乱写的

为什么说join()的位置不能乱写，我们来看两端代码

public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程A ： " + i);
            }
        });

        Thread t2 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程B ： " + i);
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("爬取结束");
    }

public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程A ： " + i);
            }
        });

        Thread t2 = new Thread(() -> {

            for (int i = 1; i < 4; i++) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程B ： " + i);
            }
        });

        t1.start();
        t1.join();

        t2.start();
        t2.join();

        System.out.println("爬取结束");
    }

虽然只是将t1.join()的位置变了一下，但是影响是非常大的，改了位置之后这段代码就变成了了这个意思，t1线程开启，紧接着t1调用了join()方法，那么就必须等待t1执行完毕之后再执行t2，所以此时的多线程代码，其实已经变成了单线程，我们来看下两段代码的执行结果。

第一段代码结果：

第二段代码结果：

很明显，第一段代码才是我们想要的多线程结果。

欢迎大家一起交流~