如何控制多线程执行顺序
前言：这道经典的面试题其实考察的是面试者对多线程API的了解程度。如果不考虑线程的API方法的话，自己脑路大开的话，方法其实很多种。今天我们就提两种最简单，也是最常用到的方法。
目标：建三个线程分别为thread1，thread2，thread3，让这三个线程依次执行。
首先，先来个多线程的实例：
package main.java;
public class App {
static Thread thread1 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread1");
}
});
static Thread thread2 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread2");
}
});
static Thread thread3 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread3");
}
});
public static void main(String[] args){
thread1.start();
thread2.start();
thread3.start();
}
}
执行结果如下：
thread1
thread2
thread3
多执行就几次：
thread3
thread1
thread2
执行多次后发现：
我们执行相同代码的结果是，每次运行结果都是随机的。
在查阅了相关资料后，我发现了一些可怕的事实：
线程在启动以后，并不是第一时间就会立马执行。而是要等待CPU的一个资源调度，而CPU调度的顺序呢是通过复杂算法计算得到的。等启动的线程得到CPU指令后，才和主线程做一个切换，执行run方法。这就造成了每次我们执行的结果都是随机的。
这里顺便补充一下线程的状态以及转换，供各位参考：
说明：
线程共包括以下5种状态。
1. 新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(01) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
(02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
(03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
方法一：Join（）使用。
先看一段代码：
package main.java;
public class App {
static Thread thread1 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread1");
}
});
static Thread thread2 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread2");
}
});
static Thread thread3 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread3");
}
});
public static void main(String[] args) throws InterruptedException{
thread1.start();
thread1.join();
thread2.start();
thread2.join();
thread3.start();
}
}
运行结果如下：
thread1
thread2
thread3
这次我们不管执行多少次都是按顺序执行的。
原理分析：
Join（）作用：让主线程等待子线程运行结束后才能继续运行。
这段代码里面的意思是这样的：
程序在main线程中调用thread1线程的join方法，则main线程放弃cpu控制权，并返回thread1线程继续执行直到线程thread1执行完毕
所以结果是thread1线程执行完后，才到主线程执行，相当于在main线程中同步thread1线程，thread1执行完了，main线程才有执行的机会
作为一个有素养的技术人，这里必须要亲自看看join（）的源码了。
/**
* Waits at most <code>millis</code> milliseconds for this thread to
* die. A timeout of <code>0</code> 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;
}
}
}
源码解读：
这里有一个isAlive()方法很重要。什么意思呢？
判断当前线程是否处于活动状态。活动状态就是线程启动且尚未终止，比如正在运行或准备开始运行。
所以从代码上看，如果线程被生成了，但还未被起动，调用它的 join() 方法是没有作用的，将直接继续向下执行。
wait()方法，什么意思呢？
在Object.java中，wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。
所以Join()主要就是通过wait()方法来实现这个目的的。
最后来个代码步骤解读吧：
1： 主线程运行；
2：创建thread1线程 （创建后的thread1线程状态为新建状态）；
3：主线程调用thread1.start()方法 （thread1线程状态变为就绪状态，等待cpu的一个资源调度，有了资源后thread1状态为运行状态）；
4：主线程调用thread1.join() 方法 （主线程会休眠，等待子线程thread1运行结束后才会继续运行）。
方法二：ExecutorService ()的使用。
依旧先看代码：
```
package main.java;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class App {
static Thread thread1 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread1");
}
});
static Thread thread2 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread2");
}
});
static Thread thread3 = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("thread3");
}
});
static ExecutorService executorService = Executors.newSingleThreadExecutor();
public static void main(String[] args) throws InterruptedException{
executorService.submit(thread1);
executorService.submit(thread2);
executorService.submit(thread3);
executorService.shutdown();
}
}
```
运行结果如下：
```
thread1
thread2
thread3
```
结果：无论运行多少次，结果都是按照我们的顺序执行的。
原理：利用并发包里的Excutors的newSingleThreadExecutor产生一个单线程的线程池，而这个线程池的底层原理就是一个先进先出（FIFO）的队列。代码中executor.submit依次添加了123线程，按照FIFO的特性，执行顺序也就是123的执行结果，从而保证了执行顺序。
这里的源码就多了，展开来太多了，有兴趣的可以自行了解一下。面试答到这两个就基本差不多了。还有很多自定义的实现也可以做到同样的效果，这里也不做展开。
