（谨以此贴感谢boss直聘首席架构师李川的指导）
这个例子是某架构师让我回来一定要理解体会试着做的一个例子，主要是避免对线程的纸上谈兵：
先来段源码
 /**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * {@code newFixedThreadPool(1)} the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    
public class AbcThread {
    public static void main(String[] args) {
        final Thread t1 =new Thread(new Runnable() {
            @Override
            public void run() {
             System.out.println(Thread.currentThread().getName()+"run 1");
            }
        },"T1");
        final  Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"run 1");
                try{
                    t1.join(10);
                }catch (InterruptedException e){
                    e.printStackTrace();

                }
            }
        },"T2");
        final  Thread t3=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"run 3");
            try{
                    t2.join(10);
            }catch (InterruptedException e){
                    e.printStackTrace();

            }
            }
        },"T3");

        ExecutorService executorService= Executors.newSingleThreadExecutor();
        executorService.submit(t1);
        executorService.submit(t2);
        executorService.submit(t3);
        executorService.shutdown();

    }
}

如何保证多线程顺序执行
代码：
public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); });​ static Thread threadB = new Thread(()->{ System.out.println("线程B"); });  static Thread threadC = new Thread(() -> { System.out.println("线程C"); }); public static void main(String[] args){ threadA.start(); threadB.start(); threadC.start(); } } 输出结果： 线程A 线程C 线程B 输出结果每次不确定
解决方案一
1、join方法
public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); });​ static Thread threadB = new Thread(()->{ System.out.println("线程B"); });  static Thread threadC = new Thread(() -> { System.out.println("线程C"); }); public static void main(String[] args) throws InterruptedException { threadA.start(); threadA.join(); threadB.start(); threadB.join(); threadC.start(); threadC.join(); } } 输出结果： 线程A 线程B 线程C
分析，join原理
a.查看jdk文档，join作用是让主线程等待子线程执行完之后再执行
jdk：join()定义
b.查看源码
join()的调用
位于main Thread的main()中，所以这里当然就是阻塞main Thread了。所以threadA.join()调用后，main Thread会阻塞起来。 
2、Executors.newSingleThreadExecutor
public class ThreadDemo { static Thread threadA = new Thread(()->{ System.out.println("线程A"); });​ static Thread threadB = new Thread(()->{ System.out.println("线程B"); });​ static Thread threadC = new Thread(() -> { System.out.println("线程C"); }); static ExecutorService executors = Executors.newSingleThreadExecutor(); public static void main(String[] args) throws InterruptedException {​ executors.submit(threadA); executors.submit(threadB); executors.submit(threadC); executors.shutdown(); }}结果：线程A线程B线程C​
分析：直接查看源代码
采用FIFO方式，保证每次只运行一个线程

其实这一个题有很多解，面试官想听的可能是CountDownLatch这一种，因为面试官也只会这一种。。

参考了网络不过总体思路没错。

public class ThreadOderRun {

    public static void main(String[] args) {
        ThreadOderRun threadOderRun = new ThreadOderRun();
        CountDownLatch l1 = new CountDownLatch(0);
        CountDownLatch l2 = new CountDownLatch(1);
        CountDownLatch l3 = new CountDownLatch(1);
        Thread work1 = new Thread(threadOderRun.new Work(l1, l2, "1"));
        Thread work2 = new Thread(threadOderRun.new Work(l2, l3, "2"));
        Thread work3 = new Thread(threadOderRun.new Work(l3, l3, "3"));
        work1.start();
        work2.start();
        work3.start();
    }


    class Work implements Runnable {
        CountDownLatch c1;
        CountDownLatch c2;
        String msg;

        public Work(CountDownLatch c1, CountDownLatch c2, String msg) {
            this.c1 = c1;
            this.msg = msg;
            this.c2=c2;
        }

        public void run() {
            try {
                c1.await();
                System.out.println(msg);
                c2.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}


如果能多几种方式就更好了

public class ThreadOrderRun2 {

    private AtomicInteger val = new AtomicInteger(1);

    public static void main(String[] args) {
        ThreadOrderRun2 threadOrderRun2 = new ThreadOrderRun2();
        Thread work1 = new Thread(threadOrderRun2.new Work("1", 1));
        Thread work2 = new Thread(threadOrderRun2.new Work("2", 2));
        Thread work3 = new Thread(threadOrderRun2.new Work("3", 3));
        work1.start();
        work2.start();
        work3.start();
    }


    class Work implements Runnable {
        private String msg;
        private int order;

        public Work(String msg, Integer order) {
            this.msg = msg;
            this.order = order;
        }

        public void run() {
            while (true) {
                try {
                    Thread.sleep(100);
                    if (val.get() == order) {
                        System.out.println(msg);
                        val.incrementAndGet();
                        break;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}


参见这个博客吧：https://blog.csdn.net/Evankaka/article/details/80800081

多线程情况下由于会有CPU在不同线程之间的来回切换，各个线程的执行结果会产生交叉 。

举个例子：现有T1、T2、T3、主线程四个线程，如何安照T1执行完才执行T2、T2执行完才执行T3、T3执行完最后执行主线程才结束？

答案：使用join()方法，让其他线程等待。使用join的线程会独占执行资源，直到使用完毕，其它线程才能获取执行权。

代码示例如下：  

public class JoinDemo {

	public static void main(String[] args) throws InterruptedException {
		// 线程t1
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
				    System.out.println("-----T1-----" + i);
				}
			}
		},"t1");
		t1.start();
		// 使用join让其他线程等待，本线程执行完成后其它线程才能执行
		t1.join();

		// 线程t2
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
				    System.out.println("-----T2-----" + i);
				}
			}
		},"t2");
		t2.start();
		// 使用join让其他线程等待，本线程执行完成后其它线程才能执行
		t2.join();

		// 线程t3
		Thread t3 = new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
				    System.out.println("-----T3-----" + i);
				}
			}
		},"t3");
		t3.start();
		// 使用join让其他线程等待，本线程执行完成后其它线程才能执行
		t3.join();

		System.out.println("-----main------");

	}

}

执行结果截图：



当然join()方法，也可以设置一个时间参数。

例如：

 

Thread t1 = new Thread();

t1 .start(); 

t1 .join(100) ;

Thread t2 = new Thread();

t2.start();

表示经过100ms后，不管t1有没有执行完毕，t2都会获得执行权。