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

要解决如上的题目，得理解题意的重心在哪。关键词：线程与顺序。

先来一段多线程执行的代码。

public class Test { 
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        Thread t3 = new Thread(new MyThread3());
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

执行结果我们是完全是可以猜测的，1、2、3线程输出的结果是无序的，因为多线程在并发环境中的正常执行顺序是随机无序的，并不能按照期盼的结果输出。因为启动一个线程时，线程并不会立即执行，而是等待CPU的资源调度，CPU能调度哪个线程，是通过多种复杂的算法计算而来，这里就不展开了。要明确的一点是，多线程运行的随机性。

为了让线程执行的顺序变的可控，将代码作了如下改良：

方法一：join

public class Test { 
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        Thread t3 = new Thread(new MyThread3());
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

join方法：让主线程等待子线程运行结束后再继续运行

有了join方法的帮忙，线程123就能按照指定的顺序执行了。

我们来看看示例当中主线程与子线程的执行顺序。在main方法中，先是调用了t1.start方法，启动t1线程，随后调用t1的join方法，main所在的主线程就需要等待t1子线程中的run方法运行完成后才能继续运行，所以主线程卡在t2.start方法之前等待t1程序。等t1运行完后，主线程重新获得主动权，继续运行t2.start和t2.join方法，与t1子线程类似，main主线程等待t2完成后继续执行，如此执行下去，join方法就有效的解决了执行顺序问题。因为在同一个时间点，各个线程是同步状态。

当然解决方法不止一个：

方法二：Excutors.newSingleThreadExecutor()

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test { 
    private static ExecutorService executor = Executors.newSingleThreadExecutor();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        Thread t3 = new Thread(new MyThread3());
        executor.submit(t1);
        executor.submit(t2);
        executor.submit(t3);
        executor.shutdown();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

利用并发包里的Excutors的newSingleThreadExecutor产生一个单线程的线程池，而这个线程池的底层原理就是一个先进先出（FIFO）的队列。代码中executor.submit依次添加了123线程，按照FIFO的特性，执行顺序也就是123的执行结果，从而保证了执行顺序。

好了，本文只提及到两个解决方案，不足之处望拍砖。