题目要求：创建三个线程，每个线程分别打印ABC，并按照ABC的顺序执行十次

题目可以使用多种不同的方式解决，下面我们分别使用 Condition 等待唤醒机制、Semaphore 信号量、CountDownLatch 闭锁、Thread.join() 方法四种方式实现题目要求。

一、使用一个 ReentrantLock 和 三个 Condition 来实现：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用一个ReentrantLock 和 三个 Condition 来实现
 */
public class PrintABCUsingCondition
{
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();

    public void execute(String flag)
    {
        lock.lock();

        for (int i = 1 ; i <= 10 ; i++){
            if ("A".equals(flag)) print(flag, conditionA, conditionB);
            if ("B".equals(flag)) print(flag, conditionB, conditionC);
            if ("C".equals(flag)) print(flag, conditionC, conditionA);
        }

        lock.unlock();
    }

    private void print(String name, Condition currentThread, Condition nextThread)
    {
        try{
            System.out.println(Thread.currentThread().getName()  + "-" + name);
            nextThread.signal();
            currentThread.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        PrintABCUsingCondition myTask = new PrintABCUsingCondition();

        new Thread(() -> myTask.execute("A")).start();
        //必须确保线程A比另外两个线程先拿到ReentrantLock，所以让主线程sleep一段时间
        Thread.sleep(500);
        new Thread(() -> myTask.execute("B")).start();
        new Thread(() -> myTask.execute("C")).start();
    }
}

二、基于 Semaphore 信号量来实现：

import java.util.concurrent.Semaphore;

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用一个Semaphore信号量来实现
 */
class PrintABCUsingSemaphore
{
    private Semaphore semaphoreA = new Semaphore(1);
    private Semaphore semaphoreB = new Semaphore(0);
    private Semaphore semaphoreC = new Semaphore(0);

    private void printA(){
        print("A", semaphoreA, semaphoreB);
    }

    private void printB(){
        print("B", semaphoreB, semaphoreC);
    }

    private void printC(){
        print("C", semaphoreC, semaphoreA);
    }

    private void print(String name, Semaphore currentSemaphore, Semaphore nextSemaphore)
    {
        for (int i = 0; i < 10; i++){
            try {
                currentSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() +" print "+ name);
                nextSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args)
    {
        PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore();
        new Thread(() -> printABC.printA()).start();
        new Thread(() -> printABC.printB()).start();
        new Thread(() -> printABC.printC()).start();
    }
}

三、基于 CountDownLatch 闭锁来实现：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 *  题目要求：ABC三个线程顺序执行10次
 *  实现思路：使用 CountDownLatch 来实现：
 * （1）定义dependLatch(所依赖的latch名)、selfLatch(自己的latch名)
 * （2）首先调用所依赖的latch的await()方法，如果所依赖的latch的count为0，则重置所依赖的latch并打印需要输出的，最后将自身的count减去
 * （3）sum为需要执行的次数
 */
public class PrintABCUsingCountDownLatch implements Runnable {

    private static Map<String, CountDownLatch> countDownLatchMap = new HashMap<>();

    private String dependLatch;
    private String selfLatch;

    private PrintABCUsingCountDownLatch(String dependLatch, String selfLatch)
    {
        this.dependLatch = dependLatch;
        this.selfLatch = selfLatch;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 10; i++)
        {
            try {
                countDownLatchMap.get(dependLatch).await();
                countDownLatchMap.put(dependLatch, new CountDownLatch(1));

                System.out.println(Thread.currentThread().getName() + ":" + selfLatch);

                countDownLatchMap.get(selfLatch).countDown();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args)
    {
        String latchA = "A";
        String latchB = "B";
        String latchC = "C";

        countDownLatchMap.put(latchA, new CountDownLatch(1));
        countDownLatchMap.put(latchB, new CountDownLatch(1));
        countDownLatchMap.put(latchC, new CountDownLatch(1));

        //创建三个线程，但是此时由于三个CountDownLatch都不为0，所以三个线程都处于阻塞状态
        Thread threadA = new Thread(new PrintABCUsingCountDownLatch(latchC, latchA));
        Thread threadB = new Thread(new PrintABCUsingCountDownLatch(latchA, latchB));
        Thread threadC = new Thread(new PrintABCUsingCountDownLatch(latchB, latchC));
        threadA.start();
        threadB.start();
        threadC.start();
        //latchC 阻塞了 latchA；调用latchC的countDown()方法，先让latchC为0，使latchA先运行
        countDownLatchMap.get(latchC).countDown();
    }

四、 使用 Thread.join() 方法来实现：

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用 Thread.join() 方法来实现
 */
public class PrintABCUsingJoin
{
    public static void main(String[] args)
    {
        Thread t0 = new Thread(new Work((null)));
        Thread t1 = new Thread(new Work((t0)));
        Thread t2 = new Thread(new Work((t1)));
        t0.start();
        t1.start();
        t2.start();
    }
}

class Work implements Runnable
{
    private Thread beforeThread;
    public Work(Thread beforeThread)
    {
        this.beforeThread = beforeThread;
    }

    @Override
    public void run()
    {
        //调用前面线程的join方法
        if(beforeThread != null)
        {
            try{
                beforeThread.join();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("当前线程：" + Thread.currentThread().getName());
    }
}