多线程顺序打印ABC

有三个线程，每个线程只能打印A，B，C。让线程顺序打印ABC十次

package cn.itcast.java.concurrency;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class ABC {
private static Lock lock = new ReentrantLock();//创建一个共同锁
private static Condition A = lock.newCondition();//创建三个等待队列
private static Condition B = lock.newCondition();
private static Condition C = lock.newCondition();
private static int count = 0;
//三个线程的策略是，A先阻塞自己，B也阻塞自己，C先叫醒A，再阻塞自己，A再叫醒B，执行一遍逻辑，再阻塞自己。B叫醒C
static class ThreadA implements Runnable{
@Override
public void run() {
lock.lock();
try{
for(int i=0;i<10;i++){
if(count%3==0){//确保第一个执行的是A
System.out.println("A");
count++;//确保第二个执行的是B
A.await();//把A，B全部放进阻塞队列，确保除了在锁中的只有一个线程在争夺锁
B.signalAll();

}else{
i--;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}

}
}

static class ThreadB implements Runnable{
@Override
public void run() {
lock.lock();
try{
for(int i=0;i<10;i++){
if(count%3==1){
System.out.println("B");
count++;
B.await();
C.signalAll();

}else{
i--;//如果B挣到第一个执行，要把多加的减回去。等于没执行
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}

}
}

static class ThreadC implements Runnable{
@Override
public void run(){
lock.lock();
try{
for(int i=0;i<10;i++){
if(count%3==2){
System.out.println("C");
count++;
A.signalAll();//先释放A让A争夺锁，此时C还在锁中，不释放，A拿不到。
C.await();

}else{
i--;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
}
public static void main(String[] args){
new Thread(new ThreadA(),"A").start();
new Thread(new ThreadB(),"B").start();
new Thread(new ThreadC(),"C").start();
}

}