场景题：现在有三个线程，同时start，用什么方法可以保证线程执行的顺序，线程一执行完线程二执行，线程二执行完线程三执行

本文介绍了三种方法来保证三个线程按特定顺序执行：使用join方法、通过线程池以及利用JUC包中的信号量和屏障。线程一执行完毕后线程二启动，线程二完成后再启动线程三。注意，使用单个线程池可能不满足题目要求，因为它通常适用于并发执行多个任务。

其实我了解到的方式无非这几种:

使用join
使用单个线程池
使用jdk1.5以后提供的JUC包的内容比如信号量、屏障…

第一种

public static void main(String[] args) {
        Thread t1 = new Thread(() -> System.out.println("t1"));
        Thread t2 = new Thread(() -> {
            try {
                //引用t1线程，等待t1线程执行完
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2");
        });
        Thread t3 = new Thread(() -> {
            try {
                //引用t2线程，等待t2线程执行完
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t3");
        });
        t3.start();
        t2.start();
        t1.start();
    }

第二种 `Executors.newSingleThreadExecutor()`

这方式似乎不合题意:因为线程池中只有1个线程,却需要执行3个任务.

第三种

public class SequenceExe {
    /**
     * 控制线程启动的闩, 三个线程 三个闩(拼音shuan)
     */
    final static CountDownLatch condition1 = new CountDownLatch(1);
    final static CountDownLatch condition2 = new CountDownLatch(1);
    final static CountDownLatch condition3 = new CountDownLatch(1);

    public static void main(String[] args) {
        Worker worker3 = new Worker(3, condition3, null);
        Worker worker2 = new Worker(2, condition2, worker3);
        Worker worker1 = new Worker(1, condition1, worker2);
        new Thread(worker1).start();
        new Thread(worker2).start();
        new Thread(worker3).start();
        // 启动第一个worker线程
        worker1.getCountDownLatch().countDown();
    }

    static class Worker implements Runnable {
        private int workerName;
        private CountDownLatch countDownLatch;
        private Worker worker;

        public Worker(int i, CountDownLatch countDownLatch, Worker worker) {
            this.workerName = i;
            this.countDownLatch = countDownLatch;
            this.worker = worker;
        }

        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("Worker{");
            sb.append("workerName=").append(workerName);
            sb.append('}');
            return sb.toString();
        }

        public CountDownLatch getCountDownLatch() {
            return countDownLatch;
        }

        @Override
        public void run() {
            try {
                // 3个程序启动时候都处于等待状态, 也算是满足题意吧?  手动捂脸.jpg
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                // 模拟在该线程在做点什么 即使将sleep注释,也不影响结果
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("index %d is done %n", workerName);
            if (worker != null) {
                // 执行完自己的,打开下一个线程的闩
                worker.getCountDownLatch().countDown();
            }
        }
    }
}