如何保证线程A,B,C顺序执行，或者C在A、B后执行？

第一种方案：使用CountDownLatch工具类

CountDownLatch：是Java多线程编程中的一个同步工具类（计数锁），它允许一个或多个线程等待其他线程完成操作后再继续执行。其内部维护了一个计数器，当线程在执行任务完成后调用countDown()方法，该方法会将计数器的值减一，而等待线程通过调用await()方法来等待计数器的值变为0后才执行。

设计实现

//设计线程类

public class ThreadA implements Runnable {
    //定时锁
    private CountDownLatch latch;

    //初始化
    public ThreadA(CountDownLatch latch){
        this.latch=latch;
    }

    @Override
    public void run() {
        //1.执行
        System.out.println("A线程执行");
        //2.计数减1
        latch.countDown();
    }
}

public class ThreadB implements Runnable {
    //两个定时锁（上一个线程和当前线程）
    private CountDownLatch latch1;
    private CountDownLatch latch2;

    //初始化
    public ThreadB(CountDownLatch latch1,CountDownLatch latch2){
        this.latch1=latch1;
        this.latch2=latch2;
    }

    @Override
    public void run() {
        try {
            //1.等待上一个线程执行完成
            latch1.await();
            //2.执行
            System.out.println("B线程执行");
            //3.计数减1
            latch2.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadC implements Runnable {
    //定时锁
    private CountDownLatch latch;

    //初始化
    public ThreadC(CountDownLatch latch){
        this.latch=latch;
    }

    @Override
    public void run() {
        try {
            //1.等待
            latch.await();
            //2.执行
            System.out.println("C线程执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//测试线程A、B、C顺序执行
public class Main {
    public static void main(String[] args) {
        //创建线程A,B的定时锁，计数为1
        CountDownLatch latchA=new CountDownLatch(1);
        CountDownLatch latchB=new CountDownLatch(1);

        //创建线程A、B、C
        Thread a = new Thread(new ThreadA(latchA));
        Thread b = new Thread(new ThreadB(latchA,latchB));
        Thread c = new Thread(new ThreadC(latchB));

        //a,b,c顺序执行
        a.start();
        b.start();
        c.start();
    }
}

第二种方案：使用Semaphore同步工具

Semaphore（信号量）：是一种控制并发访问资源的同步工具，用来限制同时访问某个资源的线程数量。Semaphore内部维护一个计数器，该计数器用于表示可用的许可证数量。线程在访问资源之前必须先通过acquire()方法获得许可证，如果许可证数量为0，则线程必须等待，直到有其他线程释放许可证。当线程使用完资源后，使用release()方法释放许可证，以便其他线程可以继续访问资源。

（实现原理和上个方案思想相同）

第三种方案：使用wait()和notify方法

。。。。