synchronized中也有条件变量，就是Monitor对象中的WaitSet，当线程条件不满足/调用wait方法后会进入WaitSet中等待
ReentrantLock的条件变量比synchronized强大之处在于，它支持多个条件变量，这就好比：

  • synchronized是那些不满足条件的线程都在一间休息室等消息
  • ReentrantLock支持多件休息室，有专门等烟的休息室，专门等早餐的休息室，唤醒时也是按休息室来唤醒

使用流程(与synchronized的wait-notify方法对比记忆)

  • await前需要获得锁(与wait方法类似)
  • await执行后，会释放锁，进入conditionObject等待
  • await的线程被唤醒、打断、超时后会重新竞争lock锁(与synchronized类似，例如从WaitSet中进入EntryList中竞争锁)
  • 竞争lock锁成功后，从await处的代码继续向后执行。(这里也复习一下wait方法，当被唤醒、打断、超时后进入EntryList，只有重新竞争到锁才会继续从wait代码处向下执行完毕，可以理解为wait-notify本身就是在synchronized块内的，如果再次执行也势必要重新获得锁)
  1. import java.util.concurrent.locks.Condition;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class TestCondition {
  5.     static ReentrantLock lock = new ReentrantLock();
  7.     public static void main(String[] args) throws InterruptedException {
  9.         //创建一个新的条件变量（休息室）
  10.         Condition condition1 = lock.newCondition();
  11.         Condition condition2 = lock.newCondition();
  13.         lock.lock();//主线程先获得锁
  14.         //进入休息室中
  15.         condition1.await();//主线程在condition1中等待
  16.     }
  17. }

创建条件变量：

  1. Condition condition1 = lock.newCondition();

线程在条件变量上等待：

  1. condition1.await()

唤醒线程：

  1. //随机唤醒在condition1对象上等待的一个线程
  2. condition1.signal();
  4. //唤醒在condition1对象上等待的所有线程
  5. condition1.signalAll();

送烟送外卖例子改为如下代码：

  1. import java.util.concurrent.locks.Condition;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class TestCondition {
  6.     static ReentrantLock ROOM = new ReentrantLock();//创建锁对象
  7.     static Condition waitCigaretteSet = ROOM.newCondition();//等待烟的队列
  8.     static Condition waitTakeoutSet = ROOM.newCondition();//等待外卖的队列
  10.     static boolean hasCigarette = false;//有没有烟
  11.     static boolean hasTakeout = false;//有没有外卖
  13.     public static void main(String[] args) throws InterruptedException {
  15.         new Thread(()->{
  16.             ROOM.lock();
  17.             try{
  18.                 System.out.println("有烟没？"+hasCigarette);
  19.                 while(!hasCigarette){
  20.                     System.out.println("没烟，先歇会儿");
  21.                     try {
  22.                         waitCigaretteSet.await();
  23.                     } catch (InterruptedException e) {
  24.                         e.printStackTrace();
  25.                     }
  26.                 }
  27.                 System.out.println("有烟没?"+hasCigarette);
  28.                 if(hasCigarette){
  29.                     System.out.println("可以开始干活了");
  30.                 }else{
  31.                     System.out.println("没干成活");
  32.                 }
  33.             }finally {
  34.                 ROOM.unlock();
  35.             }
  36.         },"小南").start();
  38.         new Thread(()->{
  39.             ROOM.lock();
  40.             try{
  41.                 System.out.println("外卖送到没？"+hasTakeout);
  42.                 while(!hasTakeout){
  43.                     System.out.println("外卖没到呢，等着吧您");
  44.                     try {
  45.                         waitTakeoutSet.await();
  46.                     } catch (InterruptedException e) {
  47.                         e.printStackTrace();
  48.                     }
  49.                 }
  50.                 System.out.println("外卖到没"+hasTakeout);
  51.                 if(hasCigarette){
  52.                     System.out.println("吃上外卖了");
  53.                 }else{
  54.                     System.out.println("饿死我了，还没吃上外卖");
  55.                 }
  56.             }finally {
  57.                 ROOM.unlock();
  58.             }
  59.         },"小女").start();
  62.         Thread.sleep(1000);//睡眠1秒
  64.         //送外卖线程
  65.         new Thread(()->{
  66.             ROOM.lock();//还是先获得锁，signal方法也要在获得锁的情况下使用
  67.             try{
  68.                 hasTakeout=true;
  69.                 waitTakeoutSet.signal();//唤醒等待线程
  70.                 System.out.println("外卖送到了嗷！");
  71.             }finally {
  72.                 ROOM.unlock();
  73.             }
  74.         },"送外卖的").start();
  76.         Thread.sleep(1000);//睡眠1秒
  78.         //送烟线程
  79.         new Thread(()->{
  80.             ROOM.lock();//还是先获得锁，signal方法也要在获得锁的情况下使用
  81.             try{
  82.                 hasCigarette=true;
  83.                 waitCigaretteSet.signal();//唤醒等待线程
  84.                 System.out.println("烟送到了嗷！");
  85.             }finally {
  86.                 ROOM.unlock();
  87.             }
  88.         },"送烟的").start();
  90.     }
  92. }

实际上与synchronized的wait-notify写法的逻辑一模一样，只是语法不同。