并发编程——3.共享模型之管程

浅浅的花香味﹌ 2024-03-31 17:24 73阅读 0赞

#### 目录 ####

*  3.共享模型之管程
 *   *  3.1.共享带来的问题
     *   *  3.1.1.Java中的体现
         *  3.1.2.问题分析
         *  3.1.3.临界区 (Critical Section)
         *  3.1.4.竞态条件 (Race Condition)
     *  3.2.synchronized 解决方案
     *  3.3.方法上的 synchronized
     *  3.4.变量的线程安全分析
     *   *  3.4.1.成员变量和静态变量是否线程安全？
         *  3.4.2.局部变量是否线程安全？
         *  3.4.3.局部变量线程安全分析
         *  3.4.4.常见线程安全类
     *  3.5.Monitor
     *   *  3.5.1.Java 对象头
         *  3.5.2. Monitor（锁）原理
     *  3.6.wait/notify
     *   *  3.6.1.API 介绍
         *  3.6.2.sleep(long n) 和 wait(long n) 的区别
         *  3.6.3.案例
     *  3.7.同步模式之保护性暂停
     *   *  3.7.1.定义
         *  3.7.2.实现
         *  3.7.3.带超时版 GuardedObject
     *  3.8.Park & Unpark
     *   *  3.8.1.基本使用
         *  3.8.2.特点
     *  3.9. 重新理解线程状态转换
     *  3.10.多把锁
     *  3.11.活跃性
     *   *  3.11.1.死锁
         *  3.11.2.定位死锁
         *  3.11.3.活锁
         *  3.11.4.饥饿
     *  3.12.ReentrantLock
     *   *  3.12.1.可重入
         *  3.12.2.可打断
         *  3.12.3.锁超时
         *  3.13.4.公平锁
         *  3.13.5.条件变量
     *  3.13.同步模式之固定运行顺序
     *   *  3.13.1. wait notify 版
         *  3.13.2.Park Unpark 版
     *  3.14.同步模式之交替执行
     *   *  3.14.1.wait notify 版
         *  3.14.2.Lock 条件变量版
         *  3.14.3.Park Unpark 版

> 本文笔记整理来自黑马视频[https://www.bilibili.com/video/BV16J411h7Rd/?p=50][https_www.bilibili.com_video_BV16J411h7Rd_p_50]，相关资料可在视频评论区进行获取。

## 3.共享模型之管程 ##

### 3.1.共享带来的问题 ###

#### 3.1.1.Java中的体现 ####

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j(topic = "c.Test17")
    public class Test17 {
        
        
        static int counter = 0;
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    counter++;
                }
            }, "t1");
        
            Thread t2 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    counter--;
                }
            }, "t2");
            
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            log.debug("counter: {}", counter);
        }
    }

某次输出结果如下：

10:29:34 [main] c.Test - counter: 2560
    
    Process finished with exit code 0

#### 3.1.2.问题分析 ####

以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析。例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
    iconst_1 	// 准备常量1
    iadd 		// 自增
    putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似：

getstatic i 	// 获取静态变量i的值
    iconst_1	 	// 准备常量1
    isub 			// 自减
    putstatic i		// 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

![在这里插入图片描述][c2f4e0bc5c6e4b3aa1c3657f253edd13.png]

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

![在这里插入图片描述][b0bfdd4bd36248d1a904b2661a25607f.png]

但多线程下这 8 行代码可能交错运行：  
**① 出现负数的情况**

![在这里插入图片描述][c1f8ea72ba2644e2a1b97a2c235366a4.png]

**② 出现正数的情况**

![在这里插入图片描述][e0ecfee03f2d4d73abbfc41113b56895.png]

#### 3.1.3.临界区 (Critical Section) ####

*  一个程序运行多个线程本身是没有问题的；
 *  问题出在多个线程访问共享资源
    
     *  多个线程读共享资源其实也没有问题；
     *  在多个线程对共享资源读写操作时发生**指令交错**，就会出现问题；
 *  一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为**临界区**；

例如，下面代码中的临界区：

static int counter = 0;
    
    static void increment()
    // 临界区
    {
        
        counter++;
    }
    
    static void decrement()
    // 临界区
    {
        
        counter--;
    }

#### 3.1.4.竞态条件 (Race Condition) ####

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了**竞态条件**。

### 3.2.synchronized 解决方案 ###

**（1）应用之互斥**  
为了避免临界区的竞态条件发生，有多种手段可以达到目的。

*  阻塞式的解决方案：synchronized，Lock；
 *  非阻塞式的解决方案：原子变量；

下面使用阻塞式的解决方案（即 synchronized）来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换。

> 注意：虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码；同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点。

**（2）语法**

synchronized(对象) // 线程 1，线程 2(blocked)
    {
        
    	临界区
    }

修改上述代码：

Thread t1 = new Thread(() -> {
        
        for (int i = 0; i < 5000; i++) {
        
            synchronized (lock) {
        
                counter++;
            }
        }
    }, "t1");
    
    Thread t2 = new Thread(() -> {
        
        for (int i = 0; i < 5000; i++) {
        
            synchronized (lock) {
        
                counter--;
            }
        }
    }, "t2");

输出结果如下：

11:00:42 [main] c.Test - counter: 0
    
    Process finished with exit code 0

**（3）分析**

![在这里插入图片描述][67ba2e761f124150918a391156d7fbfa.png]

我们可以做这样的类比：

*  synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人；
 *  当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行 count++ 代码；
 *  这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了；
 *  这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入；
 *  当 t1 执行完 synchronized\{\} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码；

用图来表示：

![在这里插入图片描述][71c77481126f4d9eba4ccd3a2b7a2dfb.png]

**（4）思考**  
synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。为了加深理解，请思考下面的问题：

*  如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性；
 *  如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象；
 *  如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象；

**（5）面向对象改进**  
把需要保护的共享变量放入一个类。

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j(topic = "c.Test17")
    public class Test17 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Room room = new Room();
            Thread t1 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    room.increment();
                }
            }, "t1");
            
            Thread t2 = new Thread(() -> {
        
                for (int i = 0; i < 5000; i++) {
        
                    room.decrement();
                }
            }, "t2");
            
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            log.debug("counter: {}", room.getCounter());
        }
    }
    
    class Room {
        
        private int counter = 0;
        
        public void increment() {
        
            synchronized (this) {
        
                counter++;
            }
        }
        
        public void decrement() {
        
            synchronized (this) {
        
                counter--;
            }
        }
        
        public int getCounter() {
        
            synchronized (this) {
        
                return counter;
            }
        }
    }

### 3.3.方法上的 synchronized ###

class Test{
        
        public synchronized void test() {
        
            
        }
    }
    //等价于
    class Test{
        
        public void test() {
        
            synchronized(this) {
        
                
            }
        }
    }

class Test{
        
        public synchronized static void test() {
        
        }
    }
    //等价于
    class Test{
        
        public static void test() {
        
            synchronized(Test.class) {
        
                
            }
        }
    }

> 不加 synchronized 的方法：不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）。

### 3.4.变量的线程安全分析 ###

#### 3.4.1.成员变量和静态变量是否线程安全？ ####

*  如果它们没有共享，则线程安全；
 *  如果它们被共享了，根据它们的状态是否能够改变，又分两种情况：
    
     *  如果只有读操作，则线程安全；
     *  如果有读写操作，则这段代码是临界区，需要考虑线程安全；

#### 3.4.2.局部变量是否线程安全？ ####

*  局部变量是线程安全的；
 *  但局部变量引用的对象则未必：
    
     *  如果该对象没有逃离方法的作用访问，它是线程安全的；
     *  如果该对象逃离方法的作用范围，需要考虑线程安全；

#### 3.4.3.局部变量线程安全分析 ####

public static void test1() {
        
        int i = 10;
        i++;
    }

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此**不存在共享**。

![在这里插入图片描述][7b018d5947074be09caa6802c90eb029.png]

而局部变量的引用稍有不同。先看一个成员变量的例子：

public class ThreadUnsafe {
        
        ArrayList<String> list = new ArrayList<>();
        
        public void method1(int loopNumber) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                // { 临界区, 会产生竞态条件
                method2();
                method3();
                
                // } 临界区
            }
        }
        
        private void method2() {
        
            list.add("1");
        }
        
        private void method3() {
        
            list.remove(0);
        }
    }

执行

static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;
    public static void main(String[] args) {
        
        ThreadUnsafe test = new ThreadUnsafe();
        for (int i = 0; i < THREAD_NUMBER; i++) {
        
            new Thread(() -> {
        
                test.method1(LOOP_NUMBER);
            }, "Thread" + i).start();
        }
    }

其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
    		 at java.util.ArrayList.rangeCheck(ArrayList.java:657)
    		 at java.util.ArrayList.remove(ArrayList.java:496)
    		 at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35)
    		 at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26)
    		 at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14)
    		 at java.lang.Thread.run(Thread.java:748)

分析：

*  无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量;
 *  method3 与 method2 分析相同；

![在这里插入图片描述][922fcb75b36249db9656e56a94a7aa3a.png]

将 list 修改为局部变量：

public class ThreadSafe {
        
        public void method1(int loopNumber) {
        
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < loopNumber; i++) {
        
                // { 临界区, 会产生竞态条件
                method2(list);
                method3(list);
                
                // } 临界区
            }
        }
        
        private void method2(ArrayList<String> list) {
        
            list.add("1");
        }
        
        private void method3(ArrayList<String> list) {
        
            list.remove(0);
        }
    }

那么就不会有上述问题了，分析：

*  list 是局部变量，每个线程调用时会创建其不同实例，没有共享；
 *  而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象；
 *  method3 的参数分析与 method2 相同；

![在这里插入图片描述][898829e98d6445dcbf2466ebb5c7dde1.png]

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？

*  情况1：有其它线程调用 method2 和 method3；
 *  情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即

> 从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】；

#### 3.4.4.常见线程安全类 ####

*  String
 *  Integer
 *  StringBuffer
 *  Random
 *  Vector
 *  Hashtable
 *  java.util.concurrent 包下的类

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为：

Hashtable table = new Hashtable();
    new Thread(()->{
        
        table.put("key", "value1");
    }).start();
    new Thread(()->{
        
        table.put("key", "value2");
    }).start();

*  它们的每个方法是原子的；
 *  但注意它们多个方法的组合不是原子的，见后面分析；

**（1）线程安全类方法的组合**  
分析下面代码是否线程安全？

Hashtable table = new Hashtable();
    // 线程1，线程2
    if( table.get("key") == null) {
        
    	table.put("key", value);
    }

![在这里插入图片描述][5965ae73839f416bbb158d5fe8af2bc7.png]

**（2）不可变类线程安全性**  
String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的。有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？通过分析源码可知，这些方法都是**生成了新的字符串对象**，而并未改变原始的字符串。

### 3.5.Monitor ###

#### 3.5.1.Java 对象头 ####

以 32 位虚拟机为例：  
**（1）普通对象**

|--------------------------------------------------------------|
    | Object Header (64 bits) |
    |------------------------------------|-------------------------|
    | Mark Word (32 bits) | Klass Word (32 bits) |
    |------------------------------------|-------------------------|

**（2）数组对象**

|---------------------------------------------------------------------------------|
    | Object Header (96 bits) |
    |--------------------------------|-----------------------|------------------------|
    | Mark Word(32bits) | Klass Word(32bits) | array length(32bits) |
    |--------------------------------|-----------------------|------------------------|

其中 Mark Word 结构为：

|-------------------------------------------------------|--------------------|
    | Mark Word (32 bits) | State |
    |-------------------------------------------------------|--------------------|
    | hashcode:25 | age:4 | biased_lock:0 | 01 | Normal |
    |-------------------------------------------------------|--------------------|
    | thread:23 | epoch:2 | age:4 | biased_lock:1 | 01 | Biased |
    |-------------------------------------------------------|--------------------|
    | ptr_to_lock_record:30 | 00 | Lightweight Locked |
    |-------------------------------------------------------|--------------------|
    | ptr_to_heavyweight_monitor:30 | 10 | Heavyweight Locked |
    |-------------------------------------------------------|--------------------|
    | | 11 | Marked for GC |
    |-------------------------------------------------------|--------------------|

**（3）64 位虚拟机 Mark Word**

|--------------------------------------------------------------------|--------------------|
    | Mark Word (64 bits) | State |
    |--------------------------------------------------------------------|--------------------|
    | unused:25 | hashcode:31 | unused:1 | age:4 | biased_lock:0 | 01 | Normal |
    |--------------------------------------------------------------------|--------------------|
    | thread:54 | epoch:2 | unused:1 | age:4 | biased_lock:1 | 01 | Biased |
    |--------------------------------------------------------------------|--------------------|
    | ptr_to_lock_record:62 | 00 | Lightweight Locked |
    |--------------------------------------------------------------------|--------------------|
    | ptr_to_heavyweight_monitor:62 | 10 | Heavyweight Locked |
    |--------------------------------------------------------------------|--------------------|
    | | 11 | Marked for GC |
    |--------------------------------------------------------------------|--------------------|

#### 3.5.2. Monitor（锁）原理 ####

Monitor 被翻译为**监视器**或**管程**，每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的 Mark Word 中就被设置指向 Monitor 对象的指针，Monitor 结构如下：

![在这里插入图片描述][51909420aa744452a1218d4a583124ac.png]

*  刚开始 Monitor 中 Owner 为 null；
 *  当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一个 Owner；
 *  在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入EntryList BLOCKED；
 *  Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是**非公平的**；
 *  图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面讲 wait-notify 时会分析；

> 注意：synchronized 必须是进入同一个对象的 monitor 才有上述的效果，不加 synchronized 的对象不会关联监视器，不遵从以上规则。

### 3.6.wait/notify ###

#### 3.6.1.API 介绍 ####

<table> 
 <thead> 
  <tr> 
   <th>obj.wait()</th> 
   <th>让进入 object 监视器的线程到 waitSet 等待</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>obj.notify()</td> 
   <td>在 object 上正在 waitSet 等待的线程中挑一个唤醒</td> 
  </tr> 
  <tr> 
   <td>obj.notifyAll()</td> 
   <td>让 object 上正在 waitSet 等待的线程全部唤醒</td> 
  </tr> 
 </tbody> 
</table>

它们都是线程之间进行协作的手段，都属于 Object 对象的方法。必须获得此对象的锁，才能调用这几个方法。

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "c.TestWaitNotify")
    public class TestWaitNotify {
        
        
        final static Object obj = new Object();
        
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                synchronized (obj) {
        
                    log.debug("执行");
                    try {
        
                        obj.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    log.debug("其它代码");
                }
            }, "t1").start();
        
            new Thread(() -> {
        
                synchronized (obj) {
        
                    log.debug("执行");
                    try {
        
                        obj.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    log.debug("其它代码");
                }
            }, "t2").start();
            
            //主线程在 2s 后执行
            TimeUnit.SECONDS.sleep(2);
            log.debug("唤醒 obj 上的其它线程");
            synchronized (obj) {
        
                //随机唤醒一个线程
                obj.notify();
                //唤醒所有线程
                //obj.notifyAll();
            }
        }
    }

notify 的一种结果如下：

12:26:08 [t1] c.TestWaitNotify - 执行
    12:26:08 [t2] c.TestWaitNotify - 执行
    12:26:10 [main] c.TestWaitNotify - 唤醒 obj 上的其它线程
    12:26:10 [t1] c.TestWaitNotify - 其它代码

notifyAll 的一种结果如下：

12:27:20 [t1] c.TestWaitNotify - 执行
    12:27:20 [t2] c.TestWaitNotify - 执行
    12:27:22 [main] c.TestWaitNotify - 唤醒 obj 上的其它线程
    12:27:22 [t2] c.TestWaitNotify - 其它代码
    12:27:22 [t1] c.TestWaitNotify - 其它代码
    
    Process finished with exit code 0

wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到notify 为止；wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是被 notify。

#### 3.6.2.sleep(long n) 和 wait(long n) 的区别 ####

1.  sleep 是 Thread 方法，而 wait 是 Object 的方法；
2.  sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用；
3.  sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁；
4.  使用它们时，线程的状态均为 TIMED\_WAITING；

#### 3.6.3.案例 ####

（1）案例代码如下：

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "c.Test19")
    public class Test19 {
        
        
        static final Object room = new Object();
        static boolean hasCigarette = false;
        static boolean hasTakeout = false;
        
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                synchronized (room) {
        
                    log.debug("有烟没？[{}]", hasCigarette);
                    while (!hasCigarette) {
        
                        log.debug("没烟，先歇会！");
                        try {
        
                            room.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("有烟没？[{}]", hasCigarette);
                    if (hasCigarette) {
        
                        log.debug("可以开始干活了");
                    } else {
        
                        log.debug("没干成活...");
                    }
                }
            }, "小南").start();
        
            new Thread(() -> {
        
                synchronized (room) {
        
                    Thread thread = Thread.currentThread();
                    log.debug("外卖送到没？[{}]", hasTakeout);
                    while (!hasTakeout) {
        
                        log.debug("没外卖，先歇会！");
                        try {
        
                            room.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("外卖送到没？[{}]", hasTakeout);
                    if (hasTakeout) {
        
                        log.debug("可以开始干活了");
                    } else {
        
                        log.debug("没干成活...");
                    }
                }
            }, "小女").start();
        
            TimeUnit.SECONDS.sleep(1);
            new Thread(() -> {
        
                synchronized (room) {
        
                    hasTakeout = true;
                    log.debug("外卖到了噢！");
                    room.notifyAll();
                }
            }, "送外卖的").start();
        }
    }

输出如下：

11:07:17 [小南] c.Test19 - 有烟没？[false]
    11:07:17 [小南] c.Test19 - 没烟，先歇会！
    11:07:17 [小女] c.Test19 - 外卖送到没？[false]
    11:07:17 [小女] c.Test19 - 没外卖，先歇会！
    11:07:18 [送外卖的] c.Test19 - 外卖到了噢！
    11:07:18 [小女] c.Test19 - 外卖送到没？[true]
    11:07:18 [小女] c.Test19 - 可以开始干活了
    11:07:18 [小南] c.Test19 - 没烟，先歇会！

（2）分析：

*  notify 只能随机唤醒一个 WaitSet 中的线程，这时如果有其它线程也在等待，那么就可能唤醒不了正确的线程，称之为**虚假唤醒**；解决方法：改为 notifyAll；
 *  用 notifyAll 仅解决某个线程的唤醒问题，但使用 if + wait 判断仅有一次机会，一旦条件不成立，就没有重新判断的机会了；解决方法：用 while + wait，当条件不成立，再次 wait；

（3）wait/notify使用模板总结：

synchronized(lock) {
        
    	while(条件不成立) {
        
    		lock.wait();
    	}
    	// 干活
    }
    //另一个线程
    synchronized(lock) {
        
    	lock.notifyAll();
    }

### 3.7.同步模式之保护性暂停 ###

#### 3.7.1.定义 ####

保护性暂停即 Guarded Suspension，用在一个线程等待另一个线程的执行结果。要点：

*  有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject；
 *  如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）；
 *  JDK 中，join 的实现、Future 的实现，采用的就是此模式；
 *  因为要等待另一方的结果，因此归类到同步模式；

![在这里插入图片描述][960b6be36bf247ee9f5c896a6004f315.png]

#### 3.7.2.实现 ####

package cn.itcast.pattern;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.nio.charset.StandardCharsets;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Downloader {
        
        public static List<String> download() throws IOException {
        
            HttpURLConnection connection = (HttpURLConnection) new URL("https://www.baidu.com/").openConnection();
            ArrayList<String> lines = new ArrayList<>();
            try (BufferedReader reader =
                         new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
        
                String line;
                while ((line = reader.readLine()) != null) {
        
                    lines.add(line);
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }
            return lines;
        }
    }

package cn.itcast.pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.IOException;
    import java.util.List;
    
    import static cn.itcast.pattern.Downloader.download;
    
    @Slf4j(topic = "c.GuardedObject")
    public class GuardedObject {
        
        private Object response;
        private final Object lock = new Object();
        
        public Object get() {
        
            synchronized (lock) {
        
                // 条件不满足则等待
                while (response == null) {
        
                    try {
        
                        lock.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                return response;
            }
        }
        
        public void complete(Object response) {
        
            synchronized (lock) {
        
                // 条件满足，通知等待线程
                this.response = response;
                lock.notifyAll();
            }
        }
        
        public static void main(String[] args) {
        
            GuardedObject guardedObject = new GuardedObject();
            new Thread(() -> {
        
                try {
        
                    // 子线程执行下载
                    List<String> response = download();
                    log.debug("download complete...");
                    guardedObject.complete(response);
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }, "t1").start();
            log.debug("waiting...");
            // 主线程阻塞等待
            Object response = guardedObject.get();
            log.debug("get response: [{}] lines", ((List<String>) response).size());
        }
    }

输出结果如下：

15:48:29 [main] c.GuardedObject - waiting...
    15:48:33 [t1] c.GuardedObject - download complete...
    15:48:33 [main] c.GuardedObject - get response: [3] lines
    
    Process finished with exit code 0

#### 3.7.3.带超时版 GuardedObject ####

如果要控制超时时间呢？

public Object get(long timeout) {
        
        synchronized (lock) {
        
            // 开始时间
            long begin = System.currentTimeMillis();
            //经历的时间
            long passedTime = 0;
            // 条件不满足则等待
            while (response == null) {
        
                //这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                //经历的时间超过了最大等待时间时，退出循环
                if (waitTime <= 0) {
        
                    break;
                }
                try {
        
                    lock.wait(waitTime);    //注意虚假唤醒问题
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                //计算经历时间
                passedTime = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }

### 3.8.Park & Unpark ###

#### 3.8.1.基本使用 ####

（1）它们是 LockSupport 类中的方法：

// 暂停当前线程
    LockSupport.park();
    
    // 恢复某个线程的运行
    LockSupport.unpark(暂停线程对象);

（2）先 park 再 unpark：

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.LockSupport;
    
    @Slf4j(topic = "c.TestParkUnpark")
    public class TestParkUnpark {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("start...");
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                log.debug("park...");
                LockSupport.park();
                log.debug("resume...");
            },"t1");
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            log.debug("unpark...");
            LockSupport.unpark(t1);
        }
    }

输出如下：

11:47:01 [t1] c.TestParkUnpark - start...
    11:47:02 [t1] c.TestParkUnpark - park...
    11:47:03 [main] c.TestParkUnpark - unpark...
    11:47:03 [t1] c.TestParkUnpark - resume...
    
    Process finished with exit code 0

（3）先 unpark 再 park：

@Slf4j(topic = "c.TestParkUnpark")
    public class TestParkUnpark {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("start...");
                try {
        
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                log.debug("park...");
                LockSupport.park();
                log.debug("resume...");
            },"t1");
            t1.start();
            TimeUnit.SECONDS.sleep(1);
            log.debug("unpark...");
            LockSupport.unpark(t1);
        }
    }

输出如下：

11:47:55 [t1] c.TestParkUnpark - start...
    11:47:56 [main] c.TestParkUnpark - unpark...
    11:47:57 [t1] c.TestParkUnpark - park...
    11:47:57 [t1] c.TestParkUnpark - resume...
    
    Process finished with exit code 0

#### 3.8.2.特点 ####

与 Object 的 wait & notify 相比：

*  wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必；
 *  park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】；
 *  park & unpark 可以先 unpark，而 wait & notify 不能先 notify；

### 3.9. 重新理解线程状态转换 ###

![在这里插入图片描述][ff878790b2e84183a609ff4c4e9fbdcc.png]

假设有线程 Thread t。

**情况 1 NEW --> RUNNABLE**  
当调用 t.start() 方法时，由 NEW --> RUNNABLE；

**情况 2 RUNNABLE <–> WAITING**  
t 线程用 synchronized(obj) 获取了对象锁后：

*  调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING；
 *  调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
    
     *  竞争锁成功，t 线程从 WAITING --> RUNNABLE；
     *  竞争锁失败，t 线程从 WAITING --> BLOCKED；

**情况 3 RUNNABLE <–> WAITING**

*  当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING（注意是当前线程在t 线程对象的监视器上等待）；
 *  t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE；

**情况 4 RUNNABLE <–> WAITING**

*  当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING；
 *  调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING -->RUNNABLE；

**情况 5 RUNNABLE <–> TIMED\_WAITING**  
t 线程用 synchronized(obj) 获取了对象锁后：

*  调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED\_WAITING；
 *  t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
    
     *  竞争锁成功，t 线程从 TIMED\_WAITING --> RUNNABLE；
     *  竞争锁失败，t 线程从 TIMED\_WAITING --> BLOCKED；

**情况 6 RUNNABLE <–> TIMED\_WAITING**

*  当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED\_WAITING（注意是当前线程在t 线程对象的监视器上等待）；
 *  当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED\_WAITING --> RUNNABLE；

**情况 7 RUNNABLE <–> TIMED\_WAITING**

*  当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED\_WAITING；
 *  当前线程等待时间超过了 n 毫秒，当前线程从 TIMED\_WAITING --> RUNNABLE；

**情况 8 RUNNABLE <–> TIMED\_WAITING**

*  当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED\_WAITING；
 *  调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从 TIMED\_WAITING–> RUNNABLE；

**情况 9 RUNNABLE <–> BLOCKED**

*  t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED；
 *  持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED；

**情况 10 RUNNABLE <–> TERMINATED**  
当前线程所有代码运行完毕，进入 TERMINATED；

### 3.10.多把锁 ###

（1）一间大屋子有两个功能：睡觉、学习，互不相干。现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低。解决方法是准备多个房间（多个对象锁），例如：

class BigRoom {
        
        public void sleep() throws InterruptedException {
        
            synchronized (this) {
        
                log.debug("sleeping 2 小时");
                TimeUnit.SECONDS.sleep(2);
            }
        }
        public void study() throws InterruptedException {
        
            synchronized (this) {
        
                log.debug("study 1 小时");
                TimeUnit.SECONDS.sleep(1);
            }
        }
    }

BigRoom bigRoom = new BigRoom();
    new Thread(() -> {
        
        bigRoom.compute();
    },"小南").start();
    new Thread(() -> {
        
        bigRoom.sleep();
    },"小女").start();

**（2）改进**

import java.util.concurrent.TimeUnit;
    
    class BigRoom {
        
        private final Object studyRoom = new Object();
        private final Object bedRoom = new Object();
        public void sleep() throws InterruptedException {
        
            synchronized (bedRoom) {
        
                log.debug("sleeping 2 小时");
                TimeUnit.SECONDS.sleep(2);
            }
        }
        public void study() throws InterruptedException {
        
            synchronized (studyRoom) {
        
                log.debug("study 1 小时");
                TimeUnit.SECONDS.sleep(1);
            }
        }
    }

将锁的粒度细分：

*  好处：可以增强并发度；
 *  坏处：如果一个线程需要同时获得多把锁，就容易发生死锁；

### 3.11.活跃性 ###

#### 3.11.1.死锁 ####

有这样的情况：一个线程需要同时获取多把锁，这时就容易发生**死锁**。t1 线程获得 A 对象锁，接下来想获取 B 对象的锁；t2 线程获得 B对象锁，接下来想获取 A 对象的锁：

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j(topic = "c.TestDeadLock")
    public class TestDeadLock {
        
        public static void main(String[] args) {
        
            Object A = new Object();
            Object B = new Object();
            Thread t1 = new Thread(() -> {
        
                synchronized (A) {
        
                    log.debug("lock A");
                    try {
        
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (B) {
        
                        log.debug("lock B");
                        log.debug("操作...");
                    }
                }
            }, "t1");
            
            Thread t2 = new Thread(() -> {
        
                synchronized (B) {
        
                    log.debug("lock B");
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (A) {
        
                        log.debug("lock A");
                        log.debug("操作...");
                    }
                    
                }
            }, "t2");
            t1.start();
            t2.start();
        }
    }

输出结果如下：

11:06:38 [t1] c.TestDeadLock - lock A
    11:06:38 [t2] c.TestDeadLock - lock B

#### 3.11.2.定位死锁 ####

（1）检测死锁可以使用 jconsole工具，或者使用 jps 定位进程 id，再用 jstack 定位死锁：

![在这里插入图片描述][2448a379e3b14d01aafc69c6202fe897.png]

![在这里插入图片描述][1dabc2f11dc14469ba1e827ec6078b53.png]

（2）避免死锁要注意加锁顺序，另外如果由于某个线程进入了死循环，导致其它线程一直等待，对于这种情况 linux 下可以通过 top 先定位到 CPU 占用高的 Java 进程，再利用 top -Hp 进程id 来定位是哪个线程，最后再用 jstack 排查。

#### 3.11.3.活锁 ####

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如：

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j(topic = "c.TestLiveLock")
    public class TestLiveLock {
        
        static volatile int count = 10;
        static final Object lock = new Object();
        
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                // 期望减到 0 退出循环
                while (count > 0) {
        
                    try {
        
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    count--;
                    log.debug("count: {}", count);
                }
            }, "t1").start();
            new Thread(() -> {
        
                // 期望超过 20 退出循环
                while (count < 20) {
        
                    try {
        
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    count++;
                    log.debug("count: {}", count);
                }
            }, "t2").start();
        }
    }

#### 3.11.4.饥饿 ####

很多教程中把饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束，饥饿的情况不易演示，讲读写锁时会涉及饥饿问题。下面讲一下遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题：

![在这里插入图片描述][f29a12acac6a4c6185730308f9319a63.png]

顺序加锁的解决方案

![在这里插入图片描述][15b7150a6b3543bb81a0da14aa515dc5.png]

### 3.12.ReentrantLock ###

（1）相对于 synchronized 它具备如下特点：

*  可中断；
 *  可以设置超时时间；
 *  可以设置为公平锁；
 *  支持多个条件变量；

（2）与 synchronized 一样，都支持可重入，基本语法如下：

// 获取锁
    reentrantLock.lock();
    try {
        
    	// 临界区
    } finally {
        
    	// 释放锁
    	reentrantLock.unlock();
    }

#### 3.12.1.可重入 ####

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "c.Test22")
    public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
        
        public static void main(String[] args) {
        
            lock.lock();
            try {
        
                log.debug("enter main");
                m1();
            } finally {
        
                lock.unlock();
            }
        }
        
        public static void m1() {
        
            lock.lock();
            try {
        
                log.debug("enter m1");
                m2();
            } finally {
        
                lock.unlock();
            }
        }
        
        public static void m2() {
        
            lock.lock();
            try {
        
                log.debug("enter m2");
            } finally {
        
                lock.unlock();
            }
        }
    }

输出结果如下：

16:19:07 [main] c.Test22 - enter main
    16:19:07 [main] c.Test22 - enter m1
    16:19:07 [main] c.Test22 - enter m2
    
    Process finished with exit code 0

#### 3.12.2.可打断 ####

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "c.Test22")
    public class Test22 {
        
        public static void main(String[] args) throws InterruptedException {
        
            ReentrantLock lock = new ReentrantLock();
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                try {
        
                    lock.lockInterruptibly();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                    log.debug("等锁的过程中被打断");
                    return;
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                TimeUnit.SECONDS.sleep(1);
                t1.interrupt();
                log.debug("执行打断");
            } finally {
        
                lock.unlock();
            }
        }
    }

输出结果如下：

16:54:58 [main] c.Test22 - 获得了锁
    16:54:58 [t1] c.Test22 - 启动...
    16:54:59 [main] c.Test22 - 执行打断
    16:54:59 [t1] c.Test22 - 等锁的过程中被打断
    java.lang.InterruptedException
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
    	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
    	at cn.itcast.test.Test22.lambda$main$0(Test22.java:15)
    	at java.lang.Thread.run(Thread.java:748)
    
    Process finished with exit code 0

注意：如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断。

#### 3.12.3.锁超时 ####

**（1）立刻失败**

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "c.Test22")
    public class Test22 {
        
        public static void main(String[] args) throws InterruptedException {
        
            ReentrantLock lock = new ReentrantLock();
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                if (!lock.tryLock()) {
        
                    log.debug("获取立刻失败，返回");
                    return;
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                TimeUnit.SECONDS.sleep(2);
            } finally {
        
                lock.unlock();
            }
        }
    }

输出结果如下：

19:00:17 [main] c.Test22 - 获得了锁
    19:00:17 [t1] c.Test22 - 启动...
    19:00:17 [t1] c.Test22 - 获取立刻失败，返回
    
    Process finished with exit code 0

**（2）超时失败**

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "c.Test22")
    public class Test22 {
        
        public static void main(String[] args) throws InterruptedException {
        
            ReentrantLock lock = new ReentrantLock();
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                try {
        
                    if (!lock.tryLock(1, TimeUnit.SECONDS)) {
        
                        log.debug("获取等待 1s 后失败，返回");
                        return;
                    }
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                TimeUnit.SECONDS.sleep(2);
            } finally {
        
                lock.unlock();
            }
        }
    }

输出结果如下：

19:02:24 [main] c.Test22 - 获得了锁
    19:02:24 [t1] c.Test22 - 启动...
    19:02:25 [t1] c.Test22 - 获取等待 1s 后失败，返回
    
    Process finished with exit code 0

#### 3.13.4.公平锁 ####

ReentrantLock 默认是不公平的。公平锁一般没有必要，会降低并发度，后面分析原理时会讲解。

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        
        sync = new NonfairSync();
    }
    
    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        
        sync = fair ? new FairSync() : new NonfairSync();
    }

#### 3.13.5.条件变量 ####

（1）synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待。ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比：

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

（2）使用要点：

*  await 前需要获得锁；
 *  await 执行后，会释放锁，进入 conditionObject 等待；
 *  await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁；
 *  竞争 lock 锁成功后，从 await 后继续执行；

（3）案例如下：

package cn.itcast.test;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j(topic = "c.Test23")
    public class Test23 {
        
        static ReentrantLock lock = new ReentrantLock();
        static Condition waitCigaretteQueue = lock.newCondition();
        static Condition waitbreakfastQueue = lock.newCondition();
        static volatile boolean hasCigrette = false;
        static volatile boolean hasBreakfast = false;
        
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                try {
        
                    lock.lock();
                    while (!hasCigrette) {
        
                        try {
        
                            waitCigaretteQueue.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("等到了它的烟");
                } finally {
        
                    lock.unlock();
                }
            }).start();
        
            new Thread(() -> {
        
                try {
        
                    lock.lock();
                    while (!hasBreakfast) {
        
                        try {
        
                            waitbreakfastQueue.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("等到了它的早餐");
                } finally {
        
                    lock.unlock();
                }
            }).start();
        
            TimeUnit.SECONDS.sleep(1);
            sendBreakfast();
            TimeUnit.SECONDS.sleep(1);
            sendCigarette();
        }
        
        private static void sendCigarette() {
        
            lock.lock();
            try {
        
                log.debug("送烟来了");
                hasCigrette = true;
                waitCigaretteQueue.signal();
            } finally {
        
                lock.unlock();
            }
        
        }
        
        private static void sendBreakfast() {
        
            lock.lock();
            try {
        
                log.debug("送早餐来了");
                hasBreakfast = true;
                waitbreakfastQueue.signal();
            } finally {
        
                lock.unlock();
            }
        }
    }

输出结果如下：

12:30:52 [main] c.Test23 - 送早餐来了
    12:30:52 [Thread-1] c.Test23 - 等到了它的早餐
    12:30:53 [main] c.Test23 - 送烟来了
    12:30:53 [Thread-0] c.Test23 - 等到了它的烟
    
    Process finished with exit code 0

### 3.13.同步模式之固定运行顺序 ###

固定运行顺序，比如，必须先 2 后 1 打印。

#### 3.13.1. wait notify 版 ####

package cn.itcast.pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j(topic = "c.TestSequentialControl")
    public class TestSequentialControl {
        
        
        //用来同步的对象
        static Object obj = new Object();
        // t2 运行标记，代表 t2 是否已经执行过
        static boolean t2runed = false;
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                synchronized (obj) {
        
                    while (!t2runed) {
        
                        // t1 先等一会儿
                        try {
        
                            obj.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
                log.debug("1");
            }, "t1");
        
            Thread t2 = new Thread(() -> {
        
                log.debug("2");
                synchronized (obj) {
        
                    //修改运行标记
                    t2runed = true;
                    //通知 obj 上等待的线程（可能有多个，因此需要使用 notifyAll）
                    obj.notifyAll();
                }
            }, "t2");
            
            t1.start();
            t2.start();
        }
    }

输出结果如下：

14:30:30 [t2] c.TestSequentialControl - 2
    14:30:30 [t1] c.TestSequentialControl - 1
    
    Process finished with exit code 0

#### 3.13.2.Park Unpark 版 ####

（1）可以看到，实现上很麻烦：

*  首先，需要保证先 wait 再 notify，否则 wait 线程永远得不到唤醒。因此使用了『运行标记』来判断该不该 wait；
 *  第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决此问题；
 *  最后，唤醒对象上的 wait 线程需要使用 notifyAll，因为『同步对象』上的等待线程可能不止一个；

（2）可以使用 LockSupport 类的 park 和 unpark 来简化上面的题目：

package cn.itcast.pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.locks.LockSupport;
    
    @Slf4j(topic = "c.TestSequentialControl")
    public class TestSequentialControl {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                LockSupport.park();
                log.debug("1");
            }, "t1");
            t1.start();
        
            Thread t2 = new Thread(() -> {
        
                log.debug("2");
                LockSupport.unpark(t1);
            }, "t2");
            t2.start();
        }
    }

输出结果如下：

15:05:18 [t2] c.TestSequentialControl - 2
    15:05:18 [t1] c.TestSequentialControl - 1
    
    Process finished with exit code 0

park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』，不需要『同步对象』和『运行标记』。

### 3.14.同步模式之交替执行 ###

线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。现在要求输出 abcabcabcabcabc 怎么实现？

#### 3.14.1.wait notify 版 ####

package cn.itcast.pattern;
    
    public class TestAlternateExecution {
        
        public static void main(String[] args) {
        
            SyncWaitNotify syncWaitNotify = new SyncWaitNotify(1, 5);
            new Thread(() -> {
        
                syncWaitNotify.print(1, 2, "a");
            }).start();
            new Thread(() -> {
        
                syncWaitNotify.print(2, 3, "b");
            }).start();
            new Thread(() -> {
        
                syncWaitNotify.print(3, 1, "c");
            }).start();
        }
    }
    
    class SyncWaitNotify {
        
        private int flag;
        private int loopNumber;
        
        public SyncWaitNotify(int flag, int loopNumber) {
        
            this.flag = flag;
            this.loopNumber = loopNumber;
        }
        
        public void print(int waitFlag, int nextFlag, String str) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                synchronized (this) {
        
                    while (this.flag != waitFlag) {
        
                        try {
        
                            this.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    System.out.print(str);
                    flag = nextFlag;
                    this.notifyAll();
                }
            }
        }
    }

结果输出如下：

abcabcabcabcabc
    Process finished with exit code 0

#### 3.14.2.Lock 条件变量版 ####

package cn.itcast.pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TestAlternateExecution {
        
        public static void main(String[] args) {
        
            AwaitSignal as = new AwaitSignal(5);
            Condition aWaitSet = as.newCondition();
            Condition bWaitSet = as.newCondition();
            Condition cWaitSet = as.newCondition();
            new Thread(() -> {
        
                as.print("a", aWaitSet, bWaitSet);
            }).start();
            new Thread(() -> {
        
                as.print("b", bWaitSet, cWaitSet);
            }).start();
            new Thread(() -> {
        
                as.print("c", cWaitSet, aWaitSet);
            }).start();
            as.start(aWaitSet);
        }
    }
    
    @Slf4j(topic = "c.AwaitSignal")
    class AwaitSignal extends ReentrantLock {
        
        //循环次数
        private int loopNumber;
        
        public AwaitSignal(int loopNumber) {
        
            this.loopNumber = loopNumber;
        }
        
        public void start(Condition first) {
        
            this.lock();
            try {
        
                log.debug("start");
                first.signal();
            } finally {
        
                this.unlock();
            }
        }
        
        public void print(String str, Condition current, Condition next) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                this.lock();
                try {
        
                    current.await();
                    System.out.print(str);
                    next.signal();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } finally {
        
                    this.unlock();
                }
            }
        }
    }

输出结果如下：

15:58:14 [main] c.AwaitSignal - start
    abcabcabcabcabc
    Process finished with exit code 0

#### 3.14.3.Park Unpark 版 ####

package cn.itcast.pattern;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.LockSupport;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TestAlternateExecution {
        
        static Thread t1;
        static Thread t2;
        static Thread t3;
        public static void main(String[] args) {
        
            ParkUnpark pu = new ParkUnpark(5);
            t1 = new Thread(() -> {
        
                pu.print("a", t2);
            });
            t2 = new Thread(() -> {
        
                pu.print("b", t3);
            });
            t3 = new Thread(() -> {
        
                pu.print("c", t1);
            });
            t1.start();
            t2.start();
            t3.start();
            LockSupport.unpark(t1);
        }
    }
    
    class ParkUnpark {
        
        private int loopNumber;
        
        public ParkUnpark(int loopNumber) {
        
            this.loopNumber = loopNumber;
        }
        
        public void print(String str, Thread next) {
        
            for (int i = 0; i < loopNumber; i++) {
        
                LockSupport.park();
                System.out.print(str);
                LockSupport.unpark(next);
            }
        }
    }

输出结果如下：

abcabcabcabcabc
    Process finished with exit code 0

![在这里插入图片描述][14e6cb487b7f4668b6bdca4cc58588bc.png]

[https_www.bilibili.com_video_BV16J411h7Rd_p_50]: https://www.bilibili.com/video/BV16J411h7Rd/?p=50
[c2f4e0bc5c6e4b3aa1c3657f253edd13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b4a573ba38074ddc813106efb46eec33.png
[b0bfdd4bd36248d1a904b2661a25607f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/88794244be6b4001a5c797872a0ed4e8.png
[c1f8ea72ba2644e2a1b97a2c235366a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/303f8b0966b04b12a820e0f23c505e45.png
[e0ecfee03f2d4d73abbfc41113b56895.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/9b3804e9a93142dfa1be954200ba6e04.png
[67ba2e761f124150918a391156d7fbfa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/6a68ca3d1a234f0b8675e1c273959003.png
[71c77481126f4d9eba4ccd3a2b7a2dfb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/fefa2c4f3a5943c48129ef65279457e6.png
[7b018d5947074be09caa6802c90eb029.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/50ff3cb793cc4e54b463b3690bdc8e13.png
[922fcb75b36249db9656e56a94a7aa3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/96ba9b66683940719d97a764305896ee.png
[898829e98d6445dcbf2466ebb5c7dde1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/411da825a6534d0da392303821f4d280.png
[5965ae73839f416bbb158d5fe8af2bc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/992b485ce59449e5a890d358ee907a7e.png
[51909420aa744452a1218d4a583124ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/92891b73b0064f599af7f953fb9230f8.png
[960b6be36bf247ee9f5c896a6004f315.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5c7a55e3a2dd445fb566a5bfbf4734d8.png
[ff878790b2e84183a609ff4c4e9fbdcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3cb2affe91384872b72d463c8aa24b3a.png
[2448a379e3b14d01aafc69c6202fe897.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e51b6c8313bc4056bf112d8ce63366c1.png
[1dabc2f11dc14469ba1e827ec6078b53.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/78a85e6125f1440bb6611223ed4f69d6.png
[f29a12acac6a4c6185730308f9319a63.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8de25c2363bc46f6b6b09c47464771e3.png
[15b7150a6b3543bb81a0da14aa515dc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/feabf440b1b74dfe97228833b2884ef2.png
[14e6cb487b7f4668b6bdca4cc58588bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/05f8141c46c14ba18bf807e0b97fbf28.png