开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推：

public static void main(String[] args) {

        final AtomicInteger state = new AtomicInteger(1);

        // 使用lock做锁  

        final ReentrantLock lock = new ReentrantLock();  

        // 获得lock锁的3个分支条件  

        final Condition c1 = lock.newCondition();  

        final Condition c2 = lock.newCondition();

        final Condition c3 = lock.newCondition();

        

        new Thread(new Runnable(){

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    try {

                        lock.lock();

                        while (state.get() != 1)

                            try {

                                // 线程1竞争到了lock, 但是发现state不为1, 说明此时还未轮到线程1打印.

                                // 因此线程1将在c1上wait

                                // 与解法一不同的是, 三个线程并非在同一个对象上wait, 也不由同一个对象唤醒

                                //使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁

                                c1.await();

                            } catch (InterruptedException e) {

                                e.printStackTrace();

                            }

                        // 如果线程1竞争到了lock, 也通过了state判定, 将执行打印任务

                        System.out.print(Thread.currentThread().getName());

                        // 打印完成后将state赋值为2, 表示下一次的打印任务将由线程2执行

                        state.incrementAndGet();

                        //唤醒一个在 await()等待队列中的线程

                        c2.signal();

                    } finally {

                        // 打印任务执行完成后需要确保锁被释放, 因此将释放锁的代码放在finally中

                        lock.unlock();

                    }

                }

            }

        },"A").start();

        

        new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    try {

                        lock.lock();

                        while (state.get() != 2)

                            try {

                                c2.await();

                            } catch (InterruptedException e) {

                                e.printStackTrace();

                            }

                        System.out.print(Thread.currentThread().getName());

                        state.incrementAndGet();

                        c3.signal();

                    } finally {

                        lock.unlock();

                    }

                }            

            }

        },"B").start();

        

        new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    try {

                        lock.lock();

                        while (state.get() != 3)

                            try {

                                c3.await();

                            } catch (InterruptedException e) {

                                e.printStackTrace();

                            }

                        System.out.print(Thread.currentThread().getName());

                        state.addAndGet(-2);

                        c1.signal();

                    } finally {

                        lock.unlock();

                    }

                }            

            }

        },"C").start();

    }