多个线程按顺序循环打印线程独有的字符串

package multithreading.analysis;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import org.junit.Test;

/**
* n个线程,每个线程打印的数字不一样,必须按顺序打印
* @author mxipjs
*
*/
public class AQSTest {
private static ReentrantLock rtl = new ReentrantLock();
private static Queue<Condition> queue = new LinkedList<Condition>();

@Test
public void test() throws InterruptedException{
ExecutorService exec = Executors.newCachedThreadPool();
for(int i=0;i<20;i++){
Condition con = rtl.newCondition();
queue.offer(con);
exec.execute(new PrintC(con,i+""));
}
TimeUnit.SECONDS.sleep(1);
rtl.lock();
try {
PrintC.signal(queue); //开始通知第一个打印线程
}finally {
rtl.unlock();
}
exec.shutdown();
while(Thread.activeCount()>2){
Thread.yield();
}
System.out.println("over");
}

static class PrintC implements Runnable {
private String printStr;
private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
protected Integer initialValue() {
return new Integer(3);
};
};
private Condition con;
public PrintC(Condition con,String str) {
this.con = con;
this.printStr = str;
}
@Override
public void run() {
while(count.get()>0){
rtl.lock();
try {
con.await();
System.out.println(printStr);
signal(queue);
count.set(count.get()-1);
} catch (InterruptedException e) {
e.printStackTrace();
} finally{
rtl.unlock();
}
}
}
public static void signal(Queue<Condition> queue){
Condition tempCondition = queue.poll();
tempCondition.signal();
queue.offer(tempCondition);
}

}
}