使用Lock

问题

三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC….”的字符串

思路

使用一个取模的判断逻辑 C%M ==N，题为 3 个线程，所以可以按取模结果编号：0、1、2，他们与 3 取模结果仍为本身，则执行打印逻辑。

代码

  1. public class PrintABCUsingLock {
  3.     private int times; // 控制打印次数
  4.     private int state;   // 当前状态值：保证三个线程之间交替打印
  5.     private Lock lock = new ReentrantLock();
  7.     public PrintABCUsingLock(int times) {
  8.         this.times = times;
  9.     }
  11.     private void printLetter(String name, int targetNum) {
  12.         for (int i = 0; i < times; ) {
  13.             lock.lock();
  14.             if (state % 3 == targetNum) {
  15.                 state++;
  16.                 i++;
  17.                 System.out.print(name);
  18.             }
  19.             lock.unlock();
  20.         }
  21.     }
  23.     public static void main(String[] args) {
  24.         PrintABCUsingLock loopThread = new PrintABCUsingLock(1);
  26.         new Thread(() -> {
  27.             loopThread.printLetter("B", 1);
  28.         }, "B").start();
  30.         new Thread(() -> {
  31.             loopThread.printLetter("A", 0);
  32.         }, "A").start();
  34.         new Thread(() -> {
  35.             loopThread.printLetter("C", 2);
  36.         }, "C").start();
  37.     }
  38. }

main 方法启动后，3 个线程会抢锁，但是 state 的初始值为 0，所以第一次执行 if 语句的内容只能是 线程 A，然后还在 for 循环之内，此时 state = 1，

只有 线程 B 才满足 1% 3 == 1，所以第二个执行的是 B，同理只有 线程 C 才满足 2% 3 == 2，所以第三个执行的是 C，执行完 ABC 之后，

才去执行第二次 for 循环，所以要把 i++ 写在 for 循环里边，不能写成 for (int i = 0; i < times;i++) 这样。

使用wait/notify

问题

三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC….”的字符串

思路

我们用对象监视器来实现，通过 wait 和 notify() 方法来实现等待、通知的逻辑，A 执行后，唤醒 B，B 执行后唤醒 C，C 执行后再唤醒 A，
这样循环的等待、唤醒来达到目的

代码

  1. public class PrintABCUsingWaitNotify {
  3.     private int state;
  4.     private int times;
  5.     private static final Object LOCK = new Object();
  7.     public PrintABCUsingWaitNotify(int times) {
  8.         this.times = times;
  9.     }
  11.     public static void main(String[] args) {
  12.         PrintABCUsingWaitNotify printABC = new PrintABCUsingWaitNotify(10);
  13.         new Thread(() -> {
  14.             printABC.printLetter("A", 0);
  15.         }, "A").start();
  16.         new Thread(() -> {
  17.             printABC.printLetter("B", 1);
  18.         }, "B").start();
  19.         new Thread(() -> {
  20.             printABC.printLetter("C", 2);
  21.         }, "C").start();
  22.     }
  24.     private void printLetter(String name, int targetState) {
  25.         for (int i = 0; i < times; i++) {
  26.             synchronized (LOCK) {
  27.                 while (state % 3 != targetState) {
  28.                     try {
  29.                         LOCK.wait();
  30.                     } catch (InterruptedException e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                 }
  34.                 state++;
  35.                 System.out.print(name);
  36.                 LOCK.notifyAll();
  37.             }
  38.         }
  39.     }
  40. }

问题

同样的思路，来解决两个线程交替打印奇数和偶数

使用对象监视器实现，两个线程 A、B 竞争同一把锁，只要其中一个线程获取锁成功，就打印 ++i，并通知另一线程从等待集合中释放，

然后自身线程加入等待集合并释放锁即可

  1. public class OddEvenPrinter {
  3.     private Object monitor = new Object();
  4.     private final int limit;
  5.     private volatile int count;
  7.     OddEvenPrinter(int initCount, int times) {
  8.         this.count = initCount;
  9.         this.limit = times;
  10.     }
  12.     public static void main(String[] args) {
  14.         OddEvenPrinter printer = new OddEvenPrinter(0, 10);
  15.         new Thread(printer::print, "odd").start();
  16.         new Thread(printer::print, "even").start();
  17.     }
  19.     private void print() {
  20.         synchronized (monitor) {
  21.             while (count < limit) {
  22.                 try {
  23.                     System.out.println(String.format("线程[%s]打印数字:%d", Thread.currentThread().getName(), ++count));
  24.                     monitor.notifyAll();
  25.                     monitor.wait();
  26.                 } catch (InterruptedException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.             }
  30.             //防止有子线程被阻塞未被唤醒，导致主线程不退出
  31.             monitor.notifyAll();
  32.         }
  33.     }
  34. }

问题

用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

  1. public class NumAndLetterPrinter {
  2.     private static char c = 'A';
  3.     private static int i = 0;
  4.     static final Object lock = new Object();
  6.     public static void main(String[] args) {
  7.         new Thread(() -> printer(), "numThread").start();
  8.         new Thread(() -> printer(), "letterThread").start();
  9.     }
  11.     private static void printer() {
  12.         synchronized (lock) {
  13.             for (int i = 0; i < 26; i++) {
  14.                 if (Thread.currentThread().getName() == "numThread") {
  15.                     //打印数字 1-26
  16.                     System.out.print((i + 1));
  17.                     // 唤醒其他在等待的线程
  18.                     lock.notifyAll();
  19.                     try {
  20.                         // 让当前线程释放锁资源，进入 wait 状态
  21.                         lock.wait();
  22.                     } catch (InterruptedException e) {
  23.                         e.printStackTrace();
  24.                     }
  25.                 } else if (Thread.currentThread().getName() == "letterThread") {
  26.                     // 打印字母 A-Z
  27.                     System.out.print((char) ('A' + i));
  28.                     // 唤醒其他在等待的线程
  29.                     lock.notifyAll();
  30.                     try {
  31.                         // 让当前线程释放锁资源，进入 wait 状态
  32.                         lock.wait();
  33.                     } catch (InterruptedException e) {
  34.                         e.printStackTrace();
  35.                     }
  36.                 }
  37.             }
  38.             lock.notifyAll();
  39.         }
  40.     }
  41. }

使用 Lock/Condition

  • Condition 中的 await() 方法相当于 Object 的 wait() 方法，Condition 中的 signal() 方法相当于 Object 的 notify() 方法，Condition 中的 signalAll() 相当于 Object 的 notifyAll() 方法。

  • 不同的是，Object 中的 wait(),notify(),notifyAll()方法是和”同步锁”(synchronized 关键字)捆绑使用的；而 Condition 是需要与”互斥锁”/“共享锁”捆绑使用的。

    问题

    三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC….”的字符串

    代码

    1. public class PrintABCUsingLockCondition {
    3.  private int times;
    4.  private int state;
    5.  private static Lock lock = new ReentrantLock();
    6.  private static Condition c1 = lock.newCondition();
    7.  private static Condition c2 = lock.newCondition();
    8.  private static Condition c3 = lock.newCondition();
    10.  public PrintABCUsingLockCondition(int times) {
    11.      this.times = times;
    12.  }
    14.  public static void main(String[] args) {
    15.      PrintABCUsingLockCondition print = new PrintABCUsingLockCondition(10);
    16.      new Thread(() -> {
    17.          print.printLetter("A", 0, c1, c2);
    18.      }, "A").start();
    19.      new Thread(() -> {
    20.          print.printLetter("B", 1, c2, c3);
    21.      }, "B").start();
    22.      new Thread(() -> {
    23.          print.printLetter("C", 2, c3, c1);
    24.      }, "C").start();
    25.  }
    27.  private void printLetter(String name, int targetState, Condition current, Condition next) {
    28.      for (int i = 0; i < times; ) {
    29.          lock.lock();
    30.          try {
    31.              while (state % 3 != targetState) {
    32.                  current.await();
    33.              }
    34.              state++;
    35.              i++;
    36.              System.out.print(name);
    37.              next.signal();
    38.          } catch (Exception e) {
    39.              e.printStackTrace();
    40.          } finally {
    41.              lock.unlock();
    42.          }
    43.      }
    44.  }
    45. }

使用 Lock 锁的多个 Condition 可以实现精准唤醒，所以碰到那种多个线程交替打印不同次数的题就比较容易想到

以上几种方式，其实都会存在一个锁的抢夺过程，如果抢锁的的线程数量足够大，就会出现很多线程抢到了锁但不该自己执行，然后就又解锁或 wait() 这种操作，这样其实是有些浪费资源的

使用 Semaphore

  • 在信号量上我们定义两种操作：信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制
  • acquire（获取） 当一个线程调用 acquire 操作时，它要么通过成功获取信号量（信号量减 1），要么一直等下去，直到有线程释放信号量，或超时。
  • release（释放）实际上会将信号量的值加 1，然后唤醒等待的线程

问题

三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC….”的字符串

代码

  1. public class PrintABCUsingSemaphore {
  2.     private int times;
  3.     private static Semaphore semaphoreA = new Semaphore(1); // 只有 A 初始信号量为 1,第一次获取到的只能是 A
  4.     private static Semaphore semaphoreB = new Semaphore(0);
  5.     private static Semaphore semaphoreC = new Semaphore(0);
  7.     public PrintABCUsingSemaphore(int times) {
  8.         this.times = times;
  9.     }
  11.     public static void main(String[] args) {
  12.         PrintABCUsingSemaphore printer = new PrintABCUsingSemaphore(1);
  13.         new Thread(() -> {
  14.             printer.print("A", semaphoreA, semaphoreB);
  15.         }, "A").start();
  17.         new Thread(() -> {
  18.             printer.print("B", semaphoreB, semaphoreC);
  19.         }, "B").start();
  21.         new Thread(() -> {
  22.             printer.print("C", semaphoreC, semaphoreA);
  23.         }, "C").start();
  24.     }
  26.     private void print(String name, Semaphore current, Semaphore next) {
  27.         for (int i = 0; i < times; i++) {
  28.             try {
  29.                 System.out.println("111" + Thread.currentThread().getName());
  30.                 current.acquire();  // A 获取信号执行,A 信号量减 1,当 A 为 0 时将无法继续获得该信号量
  31.                 System.out.print(name);
  32.                 next.release();    // B 释放信号，B 信号量加 1（初始为 0），此时可以获取 B 信号量
  33.                 System.out.println("222" + Thread.currentThread().getName());
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  38.     }
  39. }

如果题目中是多个线程循环打印的话，一般使用信号量解决是效率较高的方案，上一个线程持有下一个线程的信号量，通过一个信号量数组将全部关联起来，这种方式不会存在浪费资源的情况

问题

通过 N 个线程顺序循环打印从 0 至 100

代码

  1. public class LoopPrinter {
  3.     private final static int THREAD_COUNT = 3;
  4.     static int result = 0;
  5.     static int maxNum = 10;
  7.     public static void main(String[] args) throws InterruptedException {
  8.         final Semaphore[] semaphores = new Semaphore[THREAD_COUNT];
  9.         for (int i = 0; i < THREAD_COUNT; i++) {
  10.             //非公平信号量，每个信号量初始计数都为 1
  11.             semaphores[i] = new Semaphore(1);
  12.             if (i != THREAD_COUNT - 1) {
  13.                 System.out.println(i+"==="+semaphores[i].getQueueLength());
  14.                 //获取一个许可前线程将一直阻塞, for 循环之后只有 syncObjects[2] 没有被阻塞
  15.                 semaphores[i].acquire();
  16.             }
  17.         }
  18.         for (int i = 0; i < THREAD_COUNT; i++) {
  19.             // 初次执行，上一个信号量是 syncObjects[2]
  20.             final Semaphore lastSemphore = i == 0 ? semaphores[THREAD_COUNT - 1] : semaphores[i - 1];
  21.             final Semaphore currentSemphore = semaphores[i];
  22.             final int index = i;
  23.              new Thread(() -> {
  24.                 try {
  25.                     while (true) {
  26.                         // 初次执行，让第一个 for 循环没有阻塞的 syncObjects[2] 先获得令牌阻塞了
  27.                         lastSemphore.acquire();
  28.                         System.out.println("thread" + index + ": " + result++);
  29.                         if (result > maxNum) {
  30.                             System.exit(0);
  31.                         }
  32.                         // 释放当前的信号量，syncObjects[0] 信号量此时为 1，下次 for 循环中上一个信号量即为 syncObjects[0]
  33.                         currentSemphore.release();
  34.                     }
  35.                 } catch (Exception e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }).start();
  39.         }
  40.     }
  41. }

使用 LockSupport

  • LockSupport 是 JDK 底层的基于 sun.misc.Unsafe 来实现的类，用来创建锁和其他同步工具类的基本线程阻塞原语。
  • 它的静态方法unpark()和park()可以分别实现阻塞当前线程和唤醒指定线程的效果，所以用它解决这样的问题会更容易一些。

  • 在 AQS 中，就是通过调用 LockSupport.park( )和 LockSupport.unpark() 来实现线程的阻塞和唤醒的。

    问题

    按线程顺序打印

    代码

    1. public class PrintABCUsingLockSupport {
    3.  private static Thread threadA, threadB, threadC;
    5.  public static void main(String[] args) {
    6.      threadA = new Thread(() -> {
    7.          for (int i = 0; i < 10; i++) {
    8.              // 打印当前线程名称
    9.              System.out.print(Thread.currentThread().getName());
    10.              // 唤醒下一个线程
    11.              LockSupport.unpark(threadB);
    12.              // 当前线程阻塞
    13.              LockSupport.park();
    14.          }
    15.      }, "A");
    16.      threadB = new Thread(() -> {
    17.          for (int i = 0; i < 10; i++) {
    18.              // 先阻塞等待被唤醒
    19.              LockSupport.park();
    20.              System.out.print(Thread.currentThread().getName());
    21.              // 唤醒下一个线程
    22.              LockSupport.unpark(threadC);
    23.          }
    24.      }, "B");
    25.      threadC = new Thread(() -> {
    26.          for (int i = 0; i < 10; i++) {
    27.              // 先阻塞等待被唤醒
    28.              LockSupport.park();
    29.              System.out.print(Thread.currentThread().getName());
    30.              // 唤醒下一个线程
    31.              LockSupport.unpark(threadA);
    32.          }
    33.      }, "C");
    34.      threadA.start();
    35.      threadB.start();
    36.      threadC.start();
    37.  }
    38. }

问题

用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

代码
  1. public class NumAndLetterPrinter {
  3.     private static Thread numThread, letterThread;
  5.     public static void main(String[] args) {
  6.         letterThread = new Thread(() -> {
  7.             for (int i = 0; i < 26; i++) {
  8.                 System.out.print((char) ('A' + i));
  9.                 LockSupport.unpark(numThread);
  10.                 LockSupport.park();
  11.             }
  12.         }, "letterThread");
  14.         numThread = new Thread(() -> {
  15.             for (int i = 1; i <= 26; i++) {
  16.                 System.out.print(i);
  17.                 LockSupport.park();
  18.                 LockSupport.unpark(letterThread);
  19.             }
  20.         }, "numThread");
  21.         numThread.start();
  22.         letterThread.start();
  23.     }
  24. }