多线程轮流打印 ABC 10 遍，超简单

    static Lock lock = new ReentrantLock();
    static Condition a = lock.newCondition();
    static Condition b = lock.newCondition();
    static Condition c = lock.newCondition();

    static Thread at = new A();
    static Thread bt = new B();
    static Thread ct = new C();

    static int v = 10;

    public static void main(String[] args) throws InterruptedException {

        at.start();
        bt.start();
        ct.start();

        try {
            lock.lock();
            a.signal();
        } finally {
            lock.unlock();
        }
    }



    static class A extends Thread {

        @Override
        public void run() {
            for (; ; ) {
                if (v <= 0) {
                    bt.interrupt();
                    ct.interrupt();
                    return;
                }
                --v;

                try {
                    lock.lock();
                    a.await();
                    System.out.println("A");
                    LockSupport.parkNanos(1000);
                    b.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    static class B extends Thread {

        @Override
        public void run() {
            for (; ; ) {
                try {
                    lock.lock();
                    b.await();
                    System.out.println("B");
                    LockSupport.parkNanos(1000);
                    c.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    static class C extends Thread {

        @Override
        public void run() {
            for (; ; ) {

                try {
                    lock.lock();
                    c.await();
                    System.out.println("C-------");
                    LockSupport.parkNanos(1000);
                    a.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                } finally {
                    lock.unlock();
                }
            }
        }
    }