如何控制多线程的执行顺序？

面试的时候你是否经常被问到这样的问题：

你一般通过什么方式去控制线程的执行顺序？

碰到这样的问题，我的内心其实是很抵触的！

开什么玩笑？我怎么会控制它呢？我为什么要控制它？

其实不用慌，这个问题并不难，且听我慢慢道来…

那么，什么是线程和进程？

要想控制多线程的顺序，你首先应该搞清楚线程和进程到底是什么东西？

进程

进程其实是操作系统的基础，是系统中一次程序的执行，也是一次程序和数据在机器上顺序执行时所发生的活动，又是系统进行资源分配和调度的一个独立单位。

其实说的通俗一点，可以这么理解，进程就是Windows系统中执行的一个exe程序，是操作系统管理的基本运行单元，看下面这个图你就知道啥是进程了！

线程

线程是比进程还要小的一个单元，它是进程中独立运行的子任务。

你比如说一个微信.exe程序进程中就有非常多的子线程在同时运行，例如音视频线程、文件下载线程、信息传输线程等等，这些不同的任务如果都在一个线程去运行，那程序必定会特别慢，大家的体验不会像现在那样舒服，所以这里的每一个任务或功能都需要对应一个后台的线程在默默运行。

简单来说，线程就是组成进程的一条路径，一个进程可以包含一个或者多个线程。

什么是多线程环境?

关于多线程的环境，其实大家在使用Windows系统的时候就深有感触。

想象你一边在用IDE码代码，一边要和朋友聊天，还一边带着耳机听着音乐，你的系统为什么能够同时提供给你那么多服务呢？

其实这就是一个典型的多线程环境，你的电脑的CPU正在不断的从这些任务中飞速切换来处理程序中的各种事情，由于计算机的切换处理速度非常的快，所以你没办法在界面上进行感知，给我们的感觉就是他们其实在同时为我们服务着，这也是多线程环境的一种优势！

用一张图的方式来对比感受一下多线程的环境，例如：

在上图中，单线程环境下一号、二号处理任务是完全独立的两个任务，但是二号任务必须要等待1号任务处理完成才能执行，也就是二号处理任务必须要在程序开始后的5秒后才能运行到，最终的运行时间为15秒。

但是在多线程环境下，一号、二号虽然也是完全独立的任务，处在同一个进程中，但却由不同的线程去处理，CPU可以在这两个不同的线程之间进行切换，所以二号处理任务不需要在一号处理完成之后再处理，而是做异步处理，最终的运行时间也差不多在10秒左右。

几个关于CPU、线程执行的知识点

1、在单CPU计算机中，CPU是无法被多个程序并行使用的。

2、操作系统中存在一种调度器，它可以负责拆分CPU为一段段时间的运行片，轮流分配给不同的进程。

3、程序的运行不仅仅需要CPU，还需要很多其他资源，如内存啊，显卡啊，GPS啊，磁盘等等，这些统称为程序的执行环境，也就是程序上下文。

4、多个程序没办法同一个时间共享CPU，那怎么办呢？这个时候比进程更小的线程就出来了，通过在不同线程的切换来达到共享CPU、共享程序上下文的目的。

5、大家都知道，CPU有单核和多核区别，单核CPU其实就是多个线程会轮流得到那一个CPU核心的支持；在多核CPU中，一个核心可以服务于一个线程，例如我的电脑是4核的话，有四个线程A、B、C、D需要处理，那CPU会将他们分配到核心1、2、3、4，如果还有其他更多的线程，也必须要等待CPU的切换执行。

通过上面几个知识点，可以看出不管是在多核还是单核的系统中，CPU在多线程的环境中都是要不断切换线程来处理任务的，当然，CPU在切换任务时也不是顺便切换，而是根据一定的算法来调度、切换线程，一般有这样两种模式：分时调度和抢占式调度。

分时调度就是按照顺序平均分配；

抢占式调度就是按照优先级来进行分配。

具体的算法逻辑在这里就不再详细描述，有疑问的小伙伴们可以再继续往下深入探索…

如何去控制多线程的执行顺序？

通过一个简单的程序，体验一下线程是否会随机被执行，手动创建5个Thread对象，然后让他们按照顺序开启，如下面代码：

/**
 * 多线程Test
 */
public class Main {

    static Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread01");
        }
    });

    static Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread02");
        }
    });

    static Thread thread3 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread03");
        }
    });

    static Thread thread4 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread04");
        }
    });

    static Thread thread5 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread05");
        }
    });

    public static void main(String[] args) {
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

最后执行的结果大家一定已经猜到了，多次执行，它的顺序并不是固定的，而是随机在改变的，例如：

那么在多线程的环境中，我们有时候不想让CPU根据算法随机选取任务执行，而是想控制多线程的执行顺序，那应该如何操作呢？

目前我知道的主要有两种方法：

1、join方式
我们直接通过在每个Thread对象后面使用join方法就可以实现线程的顺序执行，代码如下：

 public static void main(String[] args) throws Exception {
        thread1.start();
        thread1.join();

        thread2.start();
        thread2.join();

        thread3.start();
        thread3.join();

        thread4.start();
        thread4.join();

        thread5.start();
        thread5.join();
    }

多次执行结果都为下面这种情况：

用join方法来保证线程顺序，其实就是让main这个主线程等待子线程结束，然后主线程再执行接下来的其他线程任务，点进去join方法我们可以了解的更透彻：

 /**
  * Waits at most {@code millis} milliseconds for this thread to
  * die. A timeout of {@code 0} means to wait forever.
  */
 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);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

源码中的参数millis默认值是0，从英文注释翻译后可以找到，0秒意味着永远等待，也就是thread1执行不完，那主线程你就要一直等着，一直wait，而代码中wait方法其实就是属于Object的方法，负责线程的休眠等待，当main主线程调用thread1.join的时候，main主线程会获得线程对象thread1的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main主线程 ，比如退出后。这就意味着main 线程调用thread1.join时，必须能够拿到线程t对象的锁。

2、ExecutorService方式
首先看一下代码，我们如何通过这种方式实现线程顺序执行：

static ExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

    public static void main(String[] args) throws Exception {
        executorService.submit(thread1);
        executorService.submit(thread2);
        executorService.submit(thread3);
        executorService.submit(thread4);
        executorService.submit(thread5);
        executorService.shutdown();
    }

最终的多次执行结果均为有序的，如下图：

解释一下，这种方式的原理其实就是将线程用排队的方式扔进一个线程池里，让所有的任务以单线程的模式，按照FIFO先进先出、LIFO后进先出、优先级等特定顺序执行，但是这种方式也是存在缺点的，就是当一个线程被阻塞时，其它的线程都会受到影响被阻塞，不过依然都会按照自身调度来执行，只是会存在阻塞延迟。

总结

总之，如果面试官真的问到大家如何控制多线程执行顺序的方法，就按照上面的两种方式回答即可，当然，面试官既然问到这个问题，就并不只是看大家是否知道这一个问题的具体答案，可能会刨根问底的让你回答更深入的一些多线程问题，所以在日常的学习过程中一定要重在积累，勤于探索，上面提到的也只是我研究到的皮毛。
最后真心希望，在以后的技术之路跟大家一起成长！