使用Condition实现顺序执行

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

/**
 * 使用Condition实现顺序执行
 * @author XML
 * @Description: TODO
 * @date: 2019年4月3日 上午8:35:30
 */
public class DemoService {

    public volatile static int nextPrintWho = 1;
    private static ReentrantLock lock = new ReentrantLock();
    
    final private static Condition conditionA = lock.newCondition();
    final private static Condition conditionB = lock.newCondition();
    final private static Condition conditionC = lock.newCondition();
    
    public static void main(String[] args) {
        Thread threadA = new Thread(){
        @Override
        public void run() {
            try {
                lock.lock();
                while (nextPrintWho != 1) {
                    conditionA.await();
                }
                for (int i = 0; i < 3; i++) {
                    System.out.println("ThreadA " + (i+1));
                }
                nextPrintWho = 2;
                conditionB.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }};
        
        Thread threadB = new Thread(){
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (nextPrintWho != 2) {
                        conditionB.await();
                    }
                    for (int i = 0; i < 3; i++) {
                        System.out.println("ThreadB " + (i+1));
                    }
                    nextPrintWho = 3;
                    conditionC.signalAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }};
            
            Thread threadC = new Thread(){
                @Override
                public void run() {
                    try {
                        lock.lock();
                        while (nextPrintWho != 3) {
                            conditionB.await();
                        }
                        for (int i = 0; i < 3; i++) {
                            System.out.println("ThreadC " + (i+1));
                        }
                        nextPrintWho = 1;
                        conditionA.signalAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }};
                
                Thread[] arrT = new Thread[5];
                Thread[] arrT2 = new Thread[5];
                Thread[] arrT3 = new Thread[5];
                
                for (int i = 0; i < 5; i++) {
                    arrT[i] = new Thread(threadA);
                    arrT2[i] = new Thread(threadB);
                    arrT3[i] = new Thread(threadC);
                    arrT[i].start();
                    arrT2[i].start();
                    arrT3[i].start();
                }
        
    }
}