• 大致思路是用条件变量作为两个线程通信的工具，然后用一个AtomicBoolean的变量作为flag保证线程间的可见性

• 代码如下

    import java.util.concurrent.atomic.AtomicBoolean;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
  
    class APrinter implements Runnable {
  
        private final Lock lock;
        private final AtomicBoolean flag;
        private final Condition waitA, waitB;
  
        APrinter(Lock lock, AtomicBoolean flag, Condition waitA, Condition waitB) {
            this.lock = lock;
            this.flag = flag;
            this.waitA = waitA;
            this.waitB = waitB;
        }
  
        @Override
        public void run() {
            while (true) {
                try {
                    lock.lock();
  
                    while (flag.get()) {
                        try {
                            waitB.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
  
                    System.out.println("A");
                    Thread.sleep(1000);
                    
                    flag.set(true);
                    waitA.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
  
    class BPrinter implements Runnable {
        private final Lock lock;
        private final AtomicBoolean flag;
        private final Condition waitA, waitB;
  
        BPrinter(Lock lock, AtomicBoolean flag, Condition waitA, Condition waitB) {
            this.lock = lock;
            this.flag = flag;
            this.waitA = waitA;
            this.waitB = waitB;
        }
  
        @Override
        public void run() {
            while (true) {
                try {
                    lock.lock();
  
                    while (!flag.get()) {
                        try {
                            waitA.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
  
                    System.out.println("B");
                    Thread.sleep(1000);
  
                    flag.set(false);
                    waitB.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
  

• 测试类

    class Test {
  
        public static void main(String[] args) throws InterruptedException {
  
            final Lock lock = new ReentrantLock();
            final Condition waitA = lock.newCondition();
            final Condition waitB = lock.newCondition();
            AtomicBoolean flag = new AtomicBoolean(false);
  
            Thread thread1 = new Thread(new APrinter(lock, flag, waitA, waitB));
            Thread thread2 = new Thread(new BPrinter(lock, flag, waitA, waitB));
  
             thread1.start();
             thread2.start();
  
              thread1.join();
              thread2.join();
        }
    }