两个线程分别交替打印A、B的一种Java写法

最新推荐文章于 2025-03-20 22:47:40 发布

原创最新推荐文章于 2025-03-20 22:47:40 发布 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

Java知识点整理专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一种使用条件变量和AtomicBoolean实现Java线程间通信的方法，以达到交替打印'A'和'B'的目标。代码示例展示了如何通过这两个工具确保线程安全和可见性。

大致思路是用条件变量作为两个线程通信的工具，然后用一个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();
      }
  }