如何确保三个线程顺序执行？

场景：有三个线程t1、t2、t3。确保三个线程t1执行完后t2执行，t2执行完成后t3执行。

1.使用join
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

t.join(); //调用join方法，等待线程t执行完毕
t.join(1000); //等待 t 线程，等待时间是1000毫秒。

一、join

package Thread;

/**
 * @author Muluo
 * @create 2021-03-13 8:13
 */
public class testThreadt1t2t3 {
    
    
    public static void main(String[] args) {
    
    

        Thread thread1 = new Thread(new work(null));
        Thread thread2 = new Thread(new work(thread1));
        Thread thread3 = new Thread(new work(thread2));
        thread1.setName("线程一");
        thread2.setName("线程二");
        thread3.setName("线程三");
        thread1.start();
        thread2.start();
        thread3.start();


    }

}
class work implements Runnable {
    
    
    private Thread thread;

    public work(Thread thread) {
    
    
        this.thread = thread;
    }

    @Override
    public void run() {
    
    
        if (thread != null) {
    
    
            try {
    
    
                thread.join();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());

        } else {
    
    
            System.out.println(Thread.currentThread().getName());
        }
    }
}

二、CountDownLatch

CountDownLatch(闭锁)是一个很有用的工具类，利用它我们可以拦截一个或多个线程使其在某个条件成熟后再执行。它的内部提供了一个计数器，在构造闭锁时必须指定计数器的初始值，且计数器的初始值必须大于0。另外它还提供了一个countDown方法来操作计数器的值，每调用一次countDown方法计数器都会减1，直到计数器的值减为0时就代表条件已成熟，所有因调用await方法而阻塞的线程都会被唤醒。这就是CountDownLatch的内部机制，看起来很简单，无非就是阻塞一部分线程让其在达到某个条件之后再执行。

public class ThreadTest2 {
    
    
 
// T1、T2、T3三个线程顺序执行
public static void main(String[] args) {
    
    
    CountDownLatch c0 = new CountDownLatch(0); //计数器为0
    CountDownLatch c1 = new CountDownLatch(1); //计数器为1
    CountDownLatch c2 = new CountDownLatch(1); //计数器为1
 
    Thread t1 = new Thread(new Work(c0, c1));
    //c0为0，t1可以执行。t1的计数器减1
 
    Thread t2 = new Thread(new Work(c1, c2));
    //t1的计数器为0时，t2才能执行。t2的计数器c2减1
 
    Thread t3 = new Thread(new Work(c2, c2));
    //t2的计数器c2为0时，t3才能执行
 
    t1.start();
    t2.start();
    t3.start();
 
}
 
//定义Work线程类，需要传入开始和结束的CountDownLatch参数
static class Work implements Runnable {
    
    
    CountDownLatch c1;
    CountDownLatch c2;
 
    Work(CountDownLatch c1, CountDownLatch c2) {
    
    
        super();
        this.c1 = c1;
        this.c2 = c2;
    }
 
    public void run() {
    
    
        try {
    
    
            c1.await();//前一线程为0才可以执行
            System.out.println("thread start:" + Thread.currentThread().getName());
            c2.countDown();//本线程计数器减少
        } catch (InterruptedException e) {
    
    
        }
 
    }
 }
}