一道面试题：新建 T1、T2、T3 三个线程，如何保证它们按顺序执行？

在多线程中有多种方法让线程按特定顺序执行，
1、可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。比如在t2
线程中使用t1.join()，在t3线程中使用t2.join()

public class JoinTest {

    public static void main(String[] args) {

        // 创建线程对象
        Thread t1 = new Thread(() -> {
            System.out.println("t1");
        }) ;

        Thread t2 = new Thread(() -> {
            try {
                t1.join();                          // 加入线程t1,只有t1线程执行完毕以后，再次执行该线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2");
        }) ;


        Thread t3 = new Thread(() -> {
            try {
                t2.join();                              // 加入线程t2,只有t2线程执行完毕以后，再次执行该线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t3");
        }) ;

        // 启动线程
        t1.start();
        t2.start();
        t3.start();

    }

}

2、使用 CountDownLatch
CountDownLatch 可以用来实现线程之间的等待和通知，也可以用来控制线程的执行顺序。例如：我们可以设置两个计数器为1的
CountDownLatch为latch1和latch2，线程1执行完成后将latch1计数器减1，线程2执行前要等待latch1为0，执行后要把latch2减1，
然后线程3执行前要等待latch2为0，也就是等待线程2执行完毕。

javaimport java.util.concurrent.CountDownLatch;

CountDownLatch latch1 = new CountDownLatch(1);
CountDownLatch latch2 = new CountDownLatch(1);

Thread T1 = new Thread(() -> {
    // T1 线程的任务
    System.out.println("T1 executed");
    latch1.countDown();  //将计数器latch1减1
});

Thread T2 = new Thread(() -> {
    try {
        // 等待 T1 执行完毕,等待latch1为0
        latch1.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // T2 线程的任务
    System.out.println("T2 executed");
    latch2.countDown();
});

Thread T3 = new Thread(() -> {
    try {
        // 等待 T2 执行完毕
        latch2.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // T3 线程的任务
    System.out.println("T3 executed");
});

// 启动三个线程
T1.start();
T2.start();
T3.start();

在这个例子中，通过 CountDownLatch 实现了 T1 执行后唤醒 T2，T2 执行后唤醒 T3，从而实现了线程的顺序执行。

3、使用 Semaphore
Semaphore 也可以用来控制并发线程的执行顺序，原理和CountDownLatch类似，可以使用两个信号量为1的信号量，线程1执行前先获取信号量1，执行完释放信号量2，线程2执行前先获取信号量2，执行完释放信号量1，线程3执行前先获取信号量1，执行完释放信号量2，这样可以控制他们的顺序。

javaimport java.util.concurrent.Semaphore;

Semaphore semaphore1 = new Semaphore(1);
Semaphore semaphore2 = new Semaphore(1);

Thread T1 = new Thread(() -> {
    try {
        semaphore1.acquire();
        // T1 线程的任务
        System.out.println("T1 executed");
        semaphore2.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

Thread T2 = new Thread(() -> {
    try {
        semaphore2.acquire();
        // T2 线程的任务
        System.out.println("T2 executed");
        semaphore1.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

Thread T3 = new Thread(() -> {
    try {
        semaphore1.acquire();
        // T3 线程的任务
        System.out.println("T3 executed");
        semaphore2.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

// 启动三个线程
T1.start();
T2.start();
T3.start();

在这个例子中，使用两个 Semaphore 实例来控制 T1、T2 和 T3 的执行顺序，确保它们按顺序执行。