JUC学习笔记(一)

---

文章目录

• • 一、进程与线程
  • • [1.1 进程与线程](#1.1 进程与线程)
    • • 1）进程
      • 2）线程
      • 3）二者对比
    • [1.2 并行与并发](#1.2 并行与并发)
    • • • 注意
  • 二、Java线程
  • • [2.1 创建和运行线程](#2.1 创建和运行线程)
    • • [1）直接使用 Thread](#1）直接使用 Thread)
      • [2）使用 Runnable 配合 Thread](#2）使用 Runnable 配合 Thread)
      • [3）FutureTask 配合 Thread](#3）FutureTask 配合 Thread)
    • [2.2 查看进程线程的方法](#2.2 查看进程线程的方法)
    • • 1）windows
      • 2）linux
      • 3）java
    • [2.3 原理之线程运行](#2.3 原理之线程运行)
    • • 栈与栈帧
      • 线程上下文切换
    • [2.4 常见方法](#2.4 常见方法)
    • [2.5 start 与 run](#2.5 start 与 run)
    • [2.6 sleep 与 yield](#2.6 sleep 与 yield)
    • • sleep
      • yield
      • 线程优先级
    • [2.7 join 方法详解](#2.7 join 方法详解)
    • • [为什么需要 join](#为什么需要 join)
      • 应用之同步
      • 有时效的join
    • [2.8 interrupt 方法详解](#2.8 interrupt 方法详解)
    • • [打断 sleep，wait，join 的线程](#打断 sleep，wait，join 的线程)
      • 打断正常运行的线程
      • 模式之两阶段终止
      • • 1）错误思路
        • 2）两阶段终止模式
      • [打断 park 线程](#打断 park 线程)
    • [2.9 不推荐的方法](#2.9 不推荐的方法)
    • [2.10 主线程与守护线程](#2.10 主线程与守护线程)
    • [2.11 五种状态](#2.11 五种状态)
    • [2.12 六种状态](#2.12 六种状态)
  • 三、共享模型之管程
  • • [3.1 共享带来的问题](#3.1 共享带来的问题)
    • • [Java 的体现](#Java 的体现)
      • 临界区
      • 竞态条件
    • [3.2 synchronized 解决方案](#3.2 synchronized 解决方案)
    • • 应用之互斥
      • synchronized
      • 面向对象改进
    • [3.3 方法上的 synchronized](#3.3 方法上的 synchronized)
    • • 线程八锁
    • [3.4 变量的线程安全分析](#3.4 变量的线程安全分析)
    • • 成员变量和静态变量是否线程安全？
      • 局部变量是否线程安全？
      • 局部变量线程安全分析
      • 常见线程安全类
      • • 线程安全类方法的组合
        • 不可变类线程安全性
      • 实例分析
    • [3.5 习题](#3.5 习题)
    • • 卖票练习
      • 转账练习
    • [3.6 Monitor 概念](#3.6 Monitor 概念)
    • • [Java 对象头](#Java 对象头)
      • [原理之 Monitor(锁)](#原理之 Monitor(锁))
      • [原理之 synchronized](#原理之 synchronized)
      • [原理之 synchronized 进阶](#原理之 synchronized 进阶)
      • • [1. 轻量级锁](#1. 轻量级锁)
        • [2. 锁膨胀](#2. 锁膨胀)
        • [3. 自旋优化](#3. 自旋优化)
        • 4.偏向锁
        • • 偏向状态
          • [撤销 - 调用对象 hashCode](#撤销 - 调用对象 hashCode)
          • [撤销 - 其它线程使用对象](#撤销 - 其它线程使用对象)
          • [撤销 - 调用 wait/notify](#撤销 - 调用 wait/notify)
          • 批量重偏向
          • 批量撤销
        • [5. 锁消除](#5. 锁消除)
    • [3.7 wait notify](#3.7 wait notify)
    • • [原理之 wait / notify](#原理之 wait / notify)
      • [API 介绍](#API 介绍)
    • [3.8 wait notify 的正确姿势](#3.8 wait notify 的正确姿势)
    • • • [sleep(long n) 和 wait(long n) 的区别](#sleep(long n) 和 wait(long n) 的区别)
        • 模式之保护性暂停
        • • 1）定义
          • 2）实现
          • [3）带超时版 GuardedObject](#3）带超时版 GuardedObject)
          • [原理之 join](#原理之 join)
          • [4）多任务版 GuardedObject](#4）多任务版 GuardedObject)
        • 模式之生产者消费者
        • • 1）定义
          • 2）实现
      • [3.9 Park & Unpark](#3.9 Park & Unpark)
      • • 基本使用
        • 特点
        • [原理之 park & unpark](#原理之 park & unpark)
      • [3.10 重新理解线程状态转换](#3.10 重新理解线程状态转换)
      • [3.11 活跃性](#3.11 活跃性)
      • • 死锁
        • 定位死锁
        • 哲学家就餐问题
        • 活锁
        • 饥饿
      • [3.12 ReentrantLock](#3.12 ReentrantLock)
      • • 可重入
        • 可打断
        • 锁超时
        • 公平锁
        • 条件变量
      • [3.13 同步模式之顺序控制](#3.13 同步模式之顺序控制)
      • • 1.固定运行顺序
        • • [1.1 wait notify 版](#1.1 wait notify 版)
          • [1.2 Park Unpark 版](#1.2 Park Unpark 版)
        • [2. 交替输出](#2. 交替输出)
        • • [2.1 wait notify 版](#2.1 wait notify 版)
          • [2.2 Lock 条件变量版](#2.2 Lock 条件变量版)
          • [2.3 Park Unpark 版](#2.3 Park Unpark 版)

---

JUC学习笔记(二)
JUC学习笔记(三)

本文记录了学习黑马程序员课程黑马程序员深入学习Java并发编程，JUC并发编程全套教程的笔记，方便查阅复习使用

一、进程与线程

1.1 进程与线程

1）进程

• 程序由指令和数据 组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程 就是用来加载指令、管理内存、管理 IO 的
• 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程
• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

2）线程

• 一个进程之内可以分为一到多个线程
• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
• Java 中，线程 作为最小调度单位 ，进程 作为资源分配的最小单位。 在 windows 中进程是不活动的，只是作 为线程的容器
• Java默认有两个线程：一个 main， 一个GC

3）二者对比

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集

• 进程拥有共享的资源，如内存空间等，供其内部的线程共享

• 进程间通信较为复杂

• 同一台计算机的进程通信称为 IPC（Inter-process communication）

• 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

• 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

1.2 并行与并发

单核 cpu 下，线程实际还是 串行执行 的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感 觉是 同时运行的 。

总结为一句话就是： 微观串行，宏观并行 ， 一般会将这种 线程轮流使用 CPU 的做法称为并发， concurrent

CPU	时间片1	时间片2	时间片3	时间片4
core	线程1	线程2	线程3	线程4

多核 cpu下，每个核（core）都可以调度运行线程，这时候线程可以是并行的。

CPU	时间片1	时间片2	时间片3	时间片4
core1	线程1	线程1	线程3	线程3
core2	线程2	线程4	线程2	线程4

• 并发（concurrent）是同一时间应对（dealing with）多件事情的能力

• 并行（parallel）是同一时刻动手做（doing）多件事情的能力

注意

1. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活
2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的

• 有些任务，经过精心设计，将任务拆分 ，并行执行 ，当然可以提高程序的运行效率。但不是所有计算任 务都能拆分
• 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义

3. IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一 直等待 IO 结束，没能充分利用线程。

二、Java线程

2.1 创建和运行线程

1）直接使用 Thread

// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
 @Override
 // run 方法内实现了要执行的任务
 public void run() {
 log.debug("hello");
 }
};
t1.start();

输出

19:19:00 [t1] c.ThreadStarter - hello

2）使用 Runnable 配合 Thread

把【线程】和【任务】（要执行的代码）分开

• Thread 代表线程
• Runnable 可运行的任务（线程要执行的代码）

// 创建任务对象
Runnable task2 = new Runnable() {
 @Override
 public void run() {
 log.debug("hello");
 }
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start()

Java 8 以后可以使用 lambda 精简代码

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

• 方法1 是把线程和任务合并在了一起，
• 方法2 是把线程和任务分开了 用 Runnable 更容易与线程池等高级 API 配合
• 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

3）FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
 log.debug("hello");
 return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

输出

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

2.2 查看进程线程的方法

1）windows

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• tasklist 查看进程
• taskkill 杀死进程

2）linux

• ps -fe 查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill 杀死进程
• top 按大写 H 切换是否显示线程
• top -H -p 查看某个进程（PID）的所有线程

3）java

• jps 命令查看所有 Java 进程
• jstack 查看某个 Java 进程（PID）的所有线程状态
• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

jconsole 远程监控配置

• 需要以如下方式运行你的 java 类

java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -Dcom.sun.management.jmxremote.authenticate=是否认证 java类

• 修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问，还需要做如下步骤

• 复制 jmxremote.password 文件
• 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
• 连接时填入 controlRole（用户名），R&D（密码）

2.3 原理之线程运行

栈与栈帧

Java 虚拟机栈

每个线程启动后，虚拟 机就会为其分配一块栈内存。

• 每个栈由多个栈帧组成，对应着每次方法调用时所占用的内存
• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

• 线程的 cpu 时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当上下文切换发生时，需要由操作系统保存当前线程的状态 ，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器，它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

• 状态 包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• 上下文切换频繁发生会影响性能

2.4 常见方法

方法名	static	功能说明	注意
start()		启动一个新线 程，在新的线程 运行 run 方法 中的代码	start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
run()		新线程启动后会 调用的方法	如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象， 来覆盖默认行为
join()		等待线程运行结 束
join(long n)		等待线程运行结 束,最多等待 n 毫秒
getId()		获取线程长整型
getName()		获取线程名
setName(String)		修改线程名
getPriority()		获取线程优先级
setPriority(int)		修改线程优先级	java中规定线程优先级是1~10 的整数，较大的优先级 能提高该线程被 CPU 调度的机率
getState()		获取线程状态	Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
isInterrupted()		判断是否被打 断，	不会清除 打断标记
isAlive()		线程是否存活 （还没有运行完 毕）
interrupt()		打断线程	如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记 ；如果打断的正在运行的线程，则会设置打断标记 ；park 的线程被打断，也会设置打断标记
interrupted()	static	判断当前线程是 否被打断	会清除 打断标记
currentThread()	static	获取当前正在执 行的线程
sleep(long n)	static	让当前执行的线 程休眠n毫秒， 休眠时让出 cpu 的时间片给其它 线程
yield()	static	提示线程调度器 让出当前线程对 CPU的使用	主要是为了测试和调试

2.5 start 与 run

• 调用run方法，程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    t1.run();
    log.debug("do other things ...");
}

将上述代码的 t1.run() 改为t1.start()

• 调用 start，程序在 t1 线程运行， FileReader.read() 方法调用是异步的

结论

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程
• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

2.6 sleep 与 yield

sleep

1. 调用 sleep 会让当前线程从 运行 进入 阻塞状态
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行，得得到cpu的时间片
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

1. 调用 yield 会让当前线程从 运行 进入就绪状态，然后调度执行其它线程
2. 具体的实现依赖于操作系统的任务调度器
3. 需要注意的是，yield()方法只是一种暗示，并不能保证一定会发生让出CPU执行权的效果。因为线程调度器可能会忽略这个暗示，导致调用yield()的线程再次获得执行权

线程优先级

• 线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
• 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

Runnable task1 = () - > {
    int count = 0;
    for (;;) {
        System.out.println("---->1 " + count++);
    }
};
Runnable task2 = () - > {
    int count = 0;
    for (;;) {
        // Thread.yield();
        System.out.println(" ---->2 " + count++);
    }
};
Thread t1 = new Thread(task1, "t1");
Thread t2 = new Thread(task2, "t2");
// t1.setPriority(Thread.MIN_PRIORITY);
// t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();

2.7 join 方法详解

为什么需要 join

下面的代码执行，打印 r 是什么？文中的sleep方法不是Thread类的sleep方法，为自定义实现的方法，单位为秒

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() - > {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

• main线程用 sleep睡眠等待结果行不行？为什么？因为实际中难以估算任务的执行时间
• 用 join，加在 t1.start() 之后即可

应用之同步

以调用方角度来讲

• 如果需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步

static int result = 0;
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() - > {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        result = 10;
    }, "t1");
    t1.start();
    t1.join();// main线程等待t1线程执行完成
    log.debug("结果为:{}", result);
}

下面代码 cost 大约多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test2();
}
private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() - > {
        sleep(1);
        r1 = 10;
    });
    Thread t2 = new Thread(() - > {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

分析如下

• 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
• 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005

如果颠倒两个 join 呢？ 最终都是输出一样的结果，因为先执行t2的join方法，此时等待2s后，接着执行t1的join，因为t1只睡了1s，在等待t2执行过程中就已经执行完了，不需要等待，因此总共也是等待了2s

有时效的join

等够时间，输出r1的值为10

static int r1 = 0;
public static void main(String[] args) throws InterruptedException {
    test3();
}
public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() - > {
        sleep(1);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {}", r1);
}

没等够时间，输出r1的值为0

static int r1 = 0;
public static void main(String[] args) throws InterruptedException {
    test3();
}
public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() - > {
        sleep(2);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {}", r1);
}

2.8 interrupt 方法详解

打断 sleep，wait，join 的线程

这几个方法都会让线程进入阻塞状态 ，打断 sleep 的线程，会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
    Thread t1 = new Thread(() - > {
        sleep(1);
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
    log.debug(" 打断状态: {}", t1.isInterrupted());
}

输出

java.lang.InterruptedException: sleep interrupted
 at java.lang.Thread.sleep(Native Method)
 at java.lang.Thread.sleep(Thread.java:340)
 at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
 at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
 at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
 at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

打断正常运行的线程

打断正常运行 的线程, 不会清空打断状态

private static void test2() throws InterruptedException {
    Thread t2 = new Thread(() - > {
        while (true) {
            Thread current = Thread.currentThread();
            boolean interrupted = current.isInterrupted();
            if (interrupted) {
                log.debug(" 打断状态: {}", interrupted);
                break;
            }
        }
    }, "t2");
    t2.start();
    sleep(0.5);
    t2.interrupt();
}

输出

20:57:37.964 [t2] c.TestInterrupt - 打断状态: true 

模式之两阶段终止

在一个线程 T1 中如何"优雅"终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

1）错误思路

• 使用线程对象的 stop() 方法停止线程 stop 方法会真正杀死线程，如果这时线程锁住了共享资源 ，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁

• 使用 System.exit(int) 方法停止线程

  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

2）两阶段终止模式

利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

@Slf4j
public class TPTInterrupt {
    private Thread thread;

    public void start() {
        thread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    // 当线程处于睡眠状态时，此时打断线程会抛出异常并清除打断标记，所以需要重新标记
                    e.printStackTrace();
                    current.interrupt();
                }
                // 执行监控操作
            }
        }, "监控线程");
        thread.start();
    }

    public void stop() {
        thread.interrupt();
    }

    public static void main(String[] args) throws InterruptedException {
        TPTInterrupt t = new TPTInterrupt();
        t.start();
        Thread.sleep(3500);
        log.debug("stop");
        t.stop();
    }
}

输出

21:33:08.454 [监控线程] DEBUG com.zhou.mode.TPTInterrupt - 将结果保存
21:33:09.472 [监控线程] DEBUG com.zhou.mode.TPTInterrupt - 将结果保存
21:33:10.485 [监控线程] DEBUG com.zhou.mode.TPTInterrupt - 将结果保存
21:33:10.938 [main] DEBUG com.zhou.mode.TPTInterrupt - stop
21:33:10.938 [监控线程] DEBUG com.zhou.mode.TPTInterrupt - 料理后事
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.zhou.mode.TPTInterrupt.lambda$start$0(TPTInterrupt.java:18)
	at java.lang.Thread.run(Thread.java:748)

利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;
    public void start() {
        thread = new Thread(() - > {
            while (true) {
                Thread current = Thread.currentThread();
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {}
                // 执行监控操作
            }
        }, "监控线程");
        thread.start();
    }
    public void stop() {
        stop = true;
        thread.interrupt();
    }
}

打断 park 线程

打断 park 线程 , 不会清空打断状态

private static void test3() throws InterruptedException {
    Thread t1 = new Thread(() - > {
        log.debug("park...");
        LockSupport.park();
        log.debug("unpark...");
        log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
}

输出

21:11:52.795 [t1] c.TestInterrupt - park...
21:11:53.295 [t1] c.TestInterrupt - unpark...
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

如果打断标记已经是 true, 则 park 会失效

private static void test4() {
    Thread t1 = new Thread(() - > {
        for (int i = 0; i < 5; i++) {
            log.debug("park...");
            LockSupport.park();
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }
    });
    t1.start();
    sleep(1);
    t1.interrupt();
}

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park...
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.812 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true

可以使用 Thread.interrupted() 清除打断状态

2.9 不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

方法名	static	功能说明
stop()		停止线程运行
suspend()		挂起（暂停）线程运行
resume()		恢复线程运行

2.10 主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束 了，即使守护线程 的代码没有执行完，也会强制结束。

比如下面代码

log.debug("开始运行...");
Thread t1 = new Thread(() - > {
    log.debug("开始运行...");
    sleep(2);
    log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

输出

08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束... 

t1守护线程睡眠时间为2s，但是非守护线程main睡眠了1s就结束了，此时t1会强制结束，注意输出结果的时间

注意

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后(其他非守护线程终止)，不会等待它们处理完当前请求

2.11 五种状态

这是从 操作系统 层面来描述的

• 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
• 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
• 【运行状态】指获取了 CPU 时间片 运行中的状态
  • 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
• 【阻塞状态】 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑 调度它们
• 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

2.12 六种状态

这是从 Java API 层面来描述的

根据 Thread.State 枚举，分为六种状态

• NEW ，线程刚被创建，但是还没有调用 start() 方法
• RUNNABLE ，当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的 【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为 是可运行）
• BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分
• TERMINATED ，当线程代码运行结束

三、共享模型之管程

3.1 共享带来的问题

Java 的体现

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

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);
}

以上的结果可能 是正数、负数、零。

因为 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 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题，但多线程下这 8 行代码可能交错运行，会产生正数、负数、零的情况

• 出现负数的情况：

• 出现正数的情况：

临界区

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

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

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

竞态条件

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

3.2 synchronized 解决方案

应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

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

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

注意

虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：

• 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
• 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized

语法

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

解决

static int counter = 0;
static final Object room = new Object();
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() - > {
        for (int i = 0; i < 5000; i++) {
            synchronized(room) {
                counter++;
            }
        }
    }, "t1");
    Thread t2 = new Thread(() - > {
        for (int i = 0; i < 5000; i++) {
            synchronized(room) {
                counter--;
            }
        }
    }, "t2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    log.debug("{}", counter);
}

你可以做这样的类比：

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

synchronized 实际是用对象锁 保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切 换所打断。

面向对象改进

把需要保护的共享变量放入一个类

class Room {
    int value = 0;
    public void increment() {
        synchronized(this) {
            value++;
        }
    }
    public void decrement() {
        synchronized(this) {
            value--;
        }
    }
    public int get() {
        synchronized(this) {
            return value;
        }
    }
}
@Slf4j
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() - > {
            for (int j = 0; j < 5000; j++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() - > {
            for (int j = 0; j < 5000; j++) {
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}", room.get());
    }
}

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 锁住的是哪个对象

• 情况1：12 或 21。锁住的是n1对象

@Slf4j(topic = "c.Number")
class Number {
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n1.b();
    }).start();
}

• 情况2：1s后12，或 2 1s后 1。锁住的是n1对象

@Slf4j(topic = "c.Number")
class Number {
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n1.b();
    }).start();
}

• 情况3：3 1s 12 或 23 1s 1 或 32 1s 1。锁住的是n1对象，方法c不受锁影响

@Slf4j(topic = "c.Number")
class Number {
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n1.b();
    }).start();
    new Thread(() - > {
        n1.c();
    }).start();
}

• 情况4：2 1s 后 1。锁住的是不同的两个对象n1和n2

@Slf4j(topic = "c.Number")
class Number {
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n2.b();
    }).start();
}

• 情况5：2 1s 后 1。锁住的是不同的两个对象n1和Number的class对象

@Slf4j(topic = "c.Number")
class Number {
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n1.b();
    }).start();
}

• 情况6：1s 后12， 或 2 1s后 1。锁住的是同一个对象Number的class

@Slf4j(topic = "c.Number")
class Number {
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n1.b();
    }).start();
}

• 情况7：2 1s 后 1。锁住的是两个不同的对象n2和class

@Slf4j(topic = "c.Number")
class Number {
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n2.b();
    }).start();
}

• 情况8：1s 后12， 或 2 1s后 1。锁住的是同一个class对象

@Slf4j(topic = "c.Number")
class Number {
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(() - > {
        n1.a();
    }).start();
    new Thread(() - > {
        n2.b();
    }).start();
}

3.4 变量的线程安全分析

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

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

局部变量是否线程安全？

• 局部变量是线程安全的
• 但局部变量引用的对象则未必
  • 如果该对象没有逃离方法的作用访问，它是线程安全的
  • 如果该对象逃离方法的作用范围（如方法调用结束时，通过return返回给调用者，逃离了原来方法的作用范围），需要考虑线程安全

局部变量线程安全分析

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

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

局部变量的引用稍有不同

先看一个成员变量的例子

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();
    }
}

其中一种情况是，线程1和线程2同时执行了add，这时list的size应该为2，但是并发增加导致线程2的值覆盖了线程1的值，size仍为1；然后线程2接着执行了remove操作，此时size为0；最后线程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 分析相同

将 list 修改为局部变量

class ThreadSafe {
    public final 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 相同

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

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

class ThreadSafe {
    // 加上final防止子类重写
    public final void method1(int loopNumber) {
        ArrayList < String > list = new ArrayList < > ();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    // 加上private修饰符，此时子类有相同的方法签名是一个新方法，并不是重写了该方法，method1是调不到子类     // 的同名方法的。
    private void method2(ArrayList < String > list) {
        list.add("1");
    }
    private void method3(ArrayList < String > list) {
        list.remove(0);
    }
}
class ThreadSafeSubClass extends ThreadSafe {
    // 如果父类的method2和method3修饰符为public，就会出现线程安全问题，父类的method1会调用子类的         // mehtod3，两个线程共同操作了list
    @Override
    public void method3(ArrayList < String > list) {
        new Thread(() - > {
            list.remove(0);
        }).start();
    }
}

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】(对扩展开放，对修改封闭)

常见线程安全类

• 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();

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

线程安全类方法的组合

分析下面代码是否线程安全？

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

线程1 线程2 table get("key")==null get("key")==null put("key", v2) put("key", v1) 线程1 线程2 table

所以要想保住组合方法的线程安全，还得在外面包一层synchronized来保证线程安全（组合方法的原子性）

不可变类线程安全性

String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的

但是String 有 replace，substring 等方法【可以】改变值，那么这些方法是如何保证线程安全的呢？

分析：

String类是用一个char数组保存数据的，如下

private final char value[];

使用了final修饰符，所以它的引用地址是不可以变的，来看看substring方法是如何实现对值修改的

public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
    	// 如果开始索引为0且结束索引等于value数组的长度直接返回原对象，否则创建一个新的对象返回
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

调用的构造方法如下

public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
    	// 对旧数组的值进行一个范围的拷贝
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

所以replace，substring 这些方法所谓的修改值，都是类似的返回一个新的对象，并不会修改原对象的值，所以原对象是线程安全的

实例分析

例1：

public class MyServlet extends HttpServlet {
    // 是否安全？不安全
    Map < String, Object > map = new HashMap < > ();
    // 是否安全？不安全
    String S1 = "...";
    // 是否安全？安全
    final String S2 = "...";
    // 是否安全？不安全
    Date D1 = new Date();
    // 是否安全？引用地址安全，但是对象中的属性是不安全的
    final Date D2 = new Date();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 使用上述变量
    }
}

例2：

public class MyServlet extends HttpServlet {
    // 是否安全？不安全，count是共享资源
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 记录调用次数
    private int count = 0;

    public void update() {
        // ...
        count++;
    }
}

例3：

@Aspect
@Component
public class MyAspect {
    // 是否安全？不安全，spring默认bean作用域为单例，可通过环绕通知并将start作为局部变量解决
    private long start = 0 L;

    @Before("execution(* *(..))")
    public void before() {
        start = System.nanoTime();
    }

    @After("execution(* *(..))")
    public void after() {
        long end = System.nanoTime();
        System.out.println("cost time:" + (end - start));
    }
}

例4：

public class MyServlet extends HttpServlet {
    // 是否安全？安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全？安全
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    public void update() {
        String sql = "update user set password = ? where username = ?";
        // 是否安全？安全
        try (Connection conn = DriverManager.getConnection("", "", "")) {
            // ...
        } catch (Exception e) {
            // ...
        }
    }
}

例5：

public class MyServlet extends HttpServlet {
    // 是否安全？安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全？安全
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全？不安全，假如线程1刚获取了连接对象，而线程2执行了conn.close操作，影响了线程1的执行
    private Connection conn = null;
    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("", "", "");
        // ...
        conn.close();
    }
}

例6：

public class MyServlet extends HttpServlet {
    // 是否安全？安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    public void update() {
        // 每个线程都创建对象
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全？安全
    private Connection = null;
    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("", "", "");
        // ...
        conn.close();
    }
}

例7：

public abstract class Test {

    public void bar() {
        // 是否安全？不安全
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        foo(sdf);
    }

    public abstract foo(SimpleDateFormat sdf);


    public static void main(String[] args) {
        new Test().bar();
    }
}

其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

public void foo(SimpleDateFormat sdf) {
    String dateStr = "1999-10-11 00:00:00";
    for (int i = 0; i < 20; i++) {
        new Thread(() - > {
            try {
                sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

所以String类中用了final来修饰，防止子类重写方法（修改value数组的值）而导致不安全的发生

3.5 习题

卖票练习

测试下面代码是否存在线程安全问题，并尝试改正

public class ExerciseSell {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow(20000);
        List<Thread> list = new ArrayList<>();
        // 用来存储买出去多少张票
        List<Integer> sellCount = new Vector<>();
        for (int i = 0; i < 10000; i++) {
            Thread t = new Thread(() -> {
                // 分析这里的竞态条件
                int count = ticketWindow.sell(randomAmount());
                sellCount.add(count);
            });
            list.add(t);
            t.start();
        }
        list.forEach((t) -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 买出去的票求和
        log.debug("selled count:{}", sellCount.stream().mapToInt(c -> c).sum());
        // 剩余票数
        log.debug("remainder count:{}", ticketWindow.getCount());
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~5
    public static int randomAmount() {
        return random.nextInt(5) + 1;
    }
}

class TicketWindow {
    private int count;

    public TicketWindow(int count) {
        this.count = count;
    }

    public int getCount() {
        return count;
    }

    public int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

只需要sell方法加上synchronized关键字即可

转账练习

测试下面代码是否存在线程安全问题，并尝试改正

@Slf4j
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
            Account a = new Account(1000);
            Account b = new Account(1000);
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    a.transfer(b, randomAmount());
                }
            }, "t1");
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    b.transfer(a, randomAmount());
                }
            }, "t2");
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            // 查看转账2000次后的总金额
            log.debug("total:{}", (a.getMoney() + b.getMoney()));
        }
        // Random 为线程安全
    static Random random = new Random();
    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}
class Account {
    private int money;
    public Account(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public void transfer(Account target, int amount) {
        if (this.money > amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }
}

错误的改正：只锁住了当前对象，没有锁住target对象，那么可能会导致线程2的target修改的值覆盖掉了线程1中this修改的值

public synchronized void transfer(Account target, int amount) {
    if (this.money > amount) {
        this.setMoney(this.getMoney() - amount);
        target.setMoney(target.getMoney() + amount);
    }
}

正确的做法：锁住同一个class对象

public void transfer(Account target, int amount) {
        synchronized (Account.class) {
            if (this.money > amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }

3.6 Monitor 概念

Java 对象头

以 32 位虚拟机为例

• 普通对象：包括标记字段和类型指针

1. 标记字段（Mark Word）：用于存储对象自身的运行时数据， 如哈希码（HashCode）、GC 分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等。
2. 类型指针（Klass Word）：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

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

• 数组对象：包括标记字段、类型指针和数组长度

|---------------------------------------------------------------------------------|
| 								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 	 |
|-------------------------------------------------------|--------------------|

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 	|
|--------------------------------------------------------------------|------------------|

原理之 Monitor(锁)

Monitor 被翻译为监视器 或管程

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

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

注意：

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

原理之 synchronized

static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
    synchronized(lock) {
        counter++;
    }
}

对应的字节码为

public static void main(java.lang.String[]);
	descriptor: ([Ljava/lang/String;)V
	flags: ACC_PUBLIC, ACC_STATIC
	Code:
    stack=2, locals=3, args_size=1
      0: getstatic #2 				// <- lock引用 （synchronized开始）
      3: dup
      4: astore_1 					// lock引用存起来 -> slot 1
      5: monitorenter 				// 将 lock对象 MarkWord 置为 Monitor 指针
      6: getstatic #3 				// <- i
      9: iconst_1 					// 准备常数 1
      10: iadd 						// +1
      11: putstatic #3 				// -> i
      14: aload_1 					// <- lock引用取出来
      15: monitorexit 				// 将 lock对象 MarkWord 重置, 唤醒 EntryList
      16: goto 24					// 跳到24行
      19: astore_2 					// e异常存起来 -> slot 2
      20: aload_1 					// <- lock引用取出来
      21: monitorexit				// 将 lock对象 MarkWord 重置, 唤醒 EntryList
      22: aload_2 					// 异常取出来<- slot 2 (e)
      23: athrow 					// throw e，抛出异常
      24: return					
	Exception table:
    from  to   target  type
      6  16    19      any          // 如果6到16行的字节码执行过程中有异常
     19  22    19      any    		// 则执行19到22行的字节码，防止程序异常无法释放锁
	LineNumberTable:
     line 8: 0
     line 9: 6
     line 10: 14
     line 11: 24
	LocalVariableTable:
     Start Length Slot Name Signature
     0     25    0 args  [Ljava/lang/String;
 	StackMapTable: number_of_entries = 2
     frame_type = 255 /* full_frame */
      offset_delta = 19
      locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
      stack = [ class java/lang/Throwable ]
     frame_type = 250 /* chop */
      offset_delta = 4           

注意

• 方法级别的 synchronized 不会在字节码指令中有所体现

原理之 synchronized 进阶

1. 轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以 使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是 synchronized

假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1() {
    synchronized(obj) {
        // 同步块 A
        method2();
    }
}
public static void method2() {
    synchronized(obj) {
        // 同步块 B
    }
}

• 创建锁记录 （Lock Record）对象，每个线程都的栈帧 都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word

• 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

• 如果 cas 替换成功，则对象头中存储了锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下

• 如果 cas 失败，有两种情况
  • 如果是其它线程已经持有了该 Object 的轻量级锁 ，这时表明有竞争，进入锁膨胀过程
  • 如果是自己执行了 synchronized 锁重入 ，那么再添加一条 Lock Record 作为重入的计数

• 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重 入计数减一

• 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象 头
  • 成功，则解锁成功
  • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2. 锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有 竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
public static void method1() {
    synchronized(obj) {
        // 同步块
    }
}

• 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁

• 这时 Thread-1 加轻量级锁失败，进入锁膨胀 流程
  • 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
  • 然后自己进入 Monitor 的 EntryList 阻塞等待

• 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，这时候会失败。这时会进入重量级解锁 流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

3. 自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步 块，释放了锁），这时当前线程就可以避免阻塞。

自旋重试成功的情况

线程 1 （core 1 上）	对象 Mark	线程 2 （core 2 上）
-	10（重量锁）	-
访问同步块，获取 monitor	10（重量锁）重量锁指针	-
成功（加锁）	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	访问同步块，获取 monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行完毕	10（重量锁）重量锁指针	自旋重试
成功（解锁）	（无锁）	自旋重试
-	10（重量锁）重量锁指针	成功（加锁）
-	10（重量锁）重量锁指针	执行同步块
-	...	...

自旋重试失败的情况：当线程2重试几次拿不到锁后进入阻塞状态

线程 1 （core 1 上）	对象 Mark	线程 2 （core 2 上）
-	10（重量锁）	-
访问同步块，获取 monitor	10（重量锁）重量锁指针	-
成功（加锁）	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	访问同步块，获取 monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	阻塞
-	...	...

• 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
• 在 Java 6 之后 自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会 高，就多自旋几次；反之，就少自旋甚至不自旋。
• Java 7 之后不能控制是否开启自旋功能。

4.偏向锁

轻量级锁在没有竞争 时（就自己这个线程），每次重入仍然需要执行 CAS 操作，消耗性能。

Java 6 中引入了偏向锁 来做进一步优化：只有第一次 使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现 这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

例如：

static final Object obj = new Object();
public static void m1() {
    synchronized(obj) {
        // 同步块 A
        m2();
    }
}
public static void m2() {
    synchronized(obj) {
        // 同步块 B
        m3();
    }
}
public static void m3() {
    synchronized(obj) {
        // 同步块 C
    }
}

偏向状态

回忆以下对象头格式

|--------------------------------------------------------------------|------------------|
| 					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 	|
|--------------------------------------------------------------------|------------------|

一个对象创建时：

• 如果开启了偏向锁（默认开启 ），那么对象创建后，markword 值为 0x05 即最后 3 位 为 101，这时它的 thread、epoch、age 都为 0
• 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 JVM 参数 - XX:BiasedLockingStartupDelay=0 来禁用延迟
• 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001 ，这时它的 hashcode、 age 都为 0，第一次用到 hashcode 时才会赋值

1）测试延迟特性

2）测试偏向锁

引入pom文件，利用 jol 第三方工具来查看对象头信息

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.14</version>
</dependency>

打印工具类

public class JolUtils {
    public static String toPrintableSimple(Object o) {
        return getHeader64Bit(o);
    }

    public static void main(String[] args) {
        System.out.println(getHeader64Bit(new Object()));
    }

    public static String getHeader64Bit(Object o) {
        VirtualMachine vm = VM.current();
        long word = vm.getLong(o, 0);
        List<String> list = new ArrayList<>(8);
        for (int i = 0; i < 8; i++) {
            list.add(toBinary((word >> i * 8) & 0xFF));
        }
        Collections.reverse(list);
        return String.join(" ", list);
    }

    // very ineffective, so what?
    private static String toBinary(long x) {
        StringBuilder s = new StringBuilder(Long.toBinaryString(x));
        int deficit = 8 - s.length();
        for (int c = 0; c < deficit; c++) {
            s.insert(0, "0");
        }
        return s.toString();
    }

}

测试代码

@Slf4j
public class BiasedLockTest {
    // 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0
    public static void main(String[] args) throws IOException {
        Dog d = new Dog();
        new Thread(() -> {
            log.debug("synchronized 前");
            System.out.println(JolUtils.toPrintableSimple(d));
            synchronized (d) {
                log.debug("synchronized 中");
                System.out.println(JolUtils.toPrintableSimple(d));
            }
            log.debug("synchronized 后");
            System.out.println(JolUtils.toPrintableSimple(d));
        }, "t1").start();
    }
    static class Dog{

    }
}

不加禁用延迟参数结果：不可偏向-轻量级锁-不可偏向

[t1] - synchronized 前 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t1] - synchronized 中 00000000 00000000 00000000 00000000 00011101 10110001 11110110 11000000
[t1] - synchronized 后 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

加禁用参数结果：可偏向-偏向锁-偏向锁

21:31:37.586 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
21:31:40.081 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 中
00000000 00000000 00000000 00000000 00011101 01011100 11111000 00000101
21:31:40.081 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 后
00000000 00000000 00000000 00000000 00011101 01011100 11111000 00000101

注意

处于偏向锁的对象解锁后，线程 id 仍存储于对象头中

3）测试禁用

在上面测试代码运行时在添加 VM 参数 -XX:-UseBiasedLocking 禁用偏向锁

输出：不可偏向-轻量级锁-不可偏向

21:34:02.168 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:34:04.597 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 中
00000000 00000000 00000000 00000000 00011110 00110101 11110111 00000000
21:34:04.597 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 后
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

撤销 - 调用对象 hashCode

调用了对象的 hashCode，但偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被 撤销，因为这时候MarkWord 没有地方存hashCode了，只能撤销偏向锁变为不可偏向。

• 轻量级锁会在锁记录中记录 hashCode
• 重量级锁会在 Monitor 中记录 hashCode

在调用 hashCode 后使用偏向锁，记得去掉 -XX:-UseBiasedLocking

输出

21:38:23.961 [main] DEBUG com.zhou.test.BiasedLockTest - 调用 hashCode:1637070917
21:38:24.004 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 前
00000000 00000000 00000000 01100001 10010011 10111000 01000101 00000001
21:38:26.442 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 中
00000000 00000000 00000000 00000000 00011110 00100110 11110110 10100000
21:38:26.442 [t1] DEBUG com.zhou.test.BiasedLockTest - synchronized 后
00000000 00000000 00000000 01100001 10010011 10111000 01000101 00000001

撤销 - 其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

private static void test2() throws InterruptedException {
        Dog d = new Dog();
        Thread t1 = new Thread(() -> {
            synchronized (d) {
                log.debug(JolUtils.toPrintableSimple(d));
            }
            synchronized (BiasedLockTest.class) {
                BiasedLockTest.class.notify();
            }
            // 如果不用 wait/notify 使用 join 必须打开下面的注释
            // 因为：t1 线程不能结束，否则底层线程可能被 jvm 重用作为 t2 线程，底层线程 id 是一样的
             /*try {
             System.in.read();
             } catch (IOException e) {
             e.printStackTrace();
             }*/
        }, "t1");
        t1.start();
        Thread t2 = new Thread(() -> {
            synchronized (BiasedLockTest.class) {
                try {
                    BiasedLockTest.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug(JolUtils.toPrintableSimple(d));
            synchronized (d) {
                log.debug(JolUtils.toPrintableSimple(d));
            }
            log.debug(JolUtils.toPrintableSimple(d));
        }, "t2");
        t2.start();
    }

输出：可偏向-偏向t1-轻量级锁-不可偏向

[t1]  - 00000000 00000000 00000000 00000000 00011101 01111000 00010000 00000101
[t2]  - 00000000 00000000 00000000 00000000 00011101 01111000 00010000 00000101
[t2]  - 00000000 00000000 00000000 00000000 00011110 00010011 11110010 11000000
[t2]  - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

撤销 - 调用 wait/notify

偏向锁升级成重量级锁

    private static void test3() {
        Dog d = new Dog();
        Thread t1 = new Thread(() -> {
            log.debug(JolUtils.toPrintableSimple(d));
            synchronized (d) {
                log.debug(JolUtils.toPrintableSimple(d));
                try {
                    d.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug(JolUtils.toPrintableSimple(d));
            }
        }, "t1");
        t1.start();
        new Thread(() -> {
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (d) {
                log.debug("notify");
                log.debug(JolUtils.toPrintableSimple(d));
                d.notify();
            }
        }, "t2").start();
    }

输出：可偏向-偏向t1-重量级锁-重量级锁

[t1] - 00000000 00000000 00000000 00000000 00011101 00100011 00011000 00000101
[t2] - notify
[t2] - 00000000 00000000 00000000 00000000 00011010 00101110 00001110 01111010
[t1] - 00000000 00000000 00000000 00000000 00011010 00101110 00001110 01111010

批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象 的 Thread ID

当撤销偏向锁阈值19 次后，jvm 会这样觉得是不是偏向错了，于是会给这些对象加锁时重新偏向至加锁线程

private static void test4() throws InterruptedException {
        Vector<Dog> list = new Vector<>();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                Dog d = new Dog();
                list.add(d);
                synchronized (d) {
                    log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                }
            }
            synchronized (list) {
                list.notify();
            }
        }, "t1");
        t1.start();

        Thread t2 = new Thread(() -> {
            synchronized (list) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("===============> ");
            for (int i = 0; i < 30; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                synchronized (d) {
                    log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                }
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
            }
        }, "t2");
        t2.start();
    }

输出：可以看到t2线程从第20次开始，偏向锁重新偏向t2线程，前面19次都撤销升级成轻量级锁

21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 0	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 1	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 2	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 3	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 4	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 5	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 6	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 7	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 8	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 9	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 10	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 11	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 12	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 13	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 14	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 15	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 16	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 17	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 18	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 19	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 20	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 21	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 22	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 23	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 24	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 25	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 26	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 27	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 28	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t1] DEBUG com.zhou.test.BiasedLockTest - 29	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - ===============> 
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 0	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 0	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 0	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 1	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 1	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 1	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 2	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 2	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 2	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 3	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 3	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 3	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 4	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 4	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 4	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 5	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 5	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 5	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 6	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 6	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 6	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 7	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 7	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 7	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 8	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 8	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 8	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 9	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 9	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 9	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 10	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 10	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 10	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 11	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 11	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 11	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 12	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 12	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.347 [t2] DEBUG com.zhou.test.BiasedLockTest - 12	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 13	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 13	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 13	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 14	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 14	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 14	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 15	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 15	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 15	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 16	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 16	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 16	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 17	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 17	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 17	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 18	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 18	00000000 00000000 00000000 00000000 00011101 01011100 11110100 10110000
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 18	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 19	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 19	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 19	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 20	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 20	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 20	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 21	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 21	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 21	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 22	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 22	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 22	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 23	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 23	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 23	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 24	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 24	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 24	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 25	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 25	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 25	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 26	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 26	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 26	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 27	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 27	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 27	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 28	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 28	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 28	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 29	00000000 00000000 00000000 00000000 00011100 11000011 00010000 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 29	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101
21:57:51.362 [t2] DEBUG com.zhou.test.BiasedLockTest - 29	00000000 00000000 00000000 00000000 00011100 11000011 00011001 00000101

批量撤销

当撤销偏向锁39 次后，jvm 会觉得确实偏向错了，根本就不该偏向。于是整个类的所有对象 都会变为不可偏向的，新建的对象也是不可偏向的

    static Thread t1, t2, t3;

    private static void test5() throws InterruptedException {
        Vector<Dog> list = new Vector<>();
        int loopNumber = 39;
        t1 = new Thread(() -> {
            for (int i = 0; i < loopNumber; i++) {
                Dog d = new Dog();
                list.add(d);
                synchronized (d) {
                    log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                }
            }
            LockSupport.unpark(t2);
        }, "t1");
        t1.start();
        t2 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                synchronized (d) {
                    log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                }
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
            }
            LockSupport.unpark(t3);
        }, "t2");
        t2.start();
        t3 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                synchronized (d) {
                    log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
                }
                log.debug(i + "\t" + JolUtils.toPrintableSimple(d));
            }
        }, "t3");
        t3.start();
        t3.join();
        log.debug(JolUtils.toPrintableSimple(new Dog()));
    }

5. 锁消除

锁消除

例如下面代码，对象o是线程安全的，所以对对象o加锁是没有任何意义的，jvm底层会优化去掉这个锁，这就是锁消除

public class MyBenchmark {
    static int x = 0;
    public void a() throws Exception {
        x++;
    }
    public void b() throws Exception {
        Object o = new Object();
        synchronized(o) {
            x++;
        }
    }
}

锁粗化

对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。

3.7 wait notify

为什么需要 wait？

由于条件不满足，某个线程不能进行计算，如果一直占用着锁，其它线程就得一直阻塞，效率太低。

原理之 wait / notify

• Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
• BLOCKED 和 WAITING 的线程都处于阻塞 状态，不占用 CPU 时间片
• BLOCKED 线程 会在 Owner 线程释放锁时唤醒
• WAITING 线程 会在 Owner 线程调用 notify 或 notifyAll 时唤醒 ，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争

API 介绍

• obj.wait() 让进入 object 监视器的线程到 waitSet 等待
• obj.notify() 在 object 上正在 waitSet 等待的线程中**挑一个(随机)**唤醒
• obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

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

@Slf4j
public class WaitTest {
    final static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait(); // 让线程在obj上一直等待下去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码....");
            }
        }).start();
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait(); // 让线程在obj上一直等待下去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码....");
            }
        }).start();
        // 主线程两秒后执行
        Thread.sleep(2000);
        log.debug("唤醒 obj 上其它线程");
        synchronized (obj) {
            obj.notify(); // 唤醒obj上一个线程
            // obj.notifyAll(); // 唤醒obj上所有等待线程
        }
    }
}

notify 的一种结果

22:27:19.144 [Thread-0] DEBUG com.zhou.test.WaitTest - 执行....
22:27:19.144 [Thread-1] DEBUG com.zhou.test.WaitTest - 执行....
22:27:21.145 [main] DEBUG com.zhou.test.WaitTest - 唤醒 obj 上其它线程
22:27:21.145 [Thread-0] DEBUG com.zhou.test.WaitTest - 其它代码....

notifyAll 的结果

22:28:56.520 [Thread-0] DEBUG com.zhou.test.WaitTest - 执行....
22:28:56.520 [Thread-1] DEBUG com.zhou.test.WaitTest - 执行....
22:28:58.520 [main] DEBUG com.zhou.test.WaitTest - 唤醒 obj 上其它线程
22:28:58.520 [Thread-1] DEBUG com.zhou.test.WaitTest - 其它代码....
22:28:58.520 [Thread-0] DEBUG com.zhou.test.WaitTest - 其它代码....

结论：

• wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到 notify 为止

• wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是被 notify，结束等待后仍需进入 EntryList重新竞争锁

3.8 wait notify 的正确姿势

sleep(long n) 和 wait(long n) 的区别

1. sleep 是 Thread 方法，而 wait 是 Object 的方法

2. sleep 不需要强制和 synchronized 配合使用，但 wait 需要 和 synchronized 一起用

3. sleep 在睡眠的同时，不会释放对象锁 的，但 wait 在等待的时候会释放对象锁

4. 它们状态都是 TIMED_WAITING

模式之保护性暂停

1）定义

即 Guarded Suspension，用在一个线程等待另一个线程的执行结果

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

2）实现

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();
            }
        }).start();
        log.debug("waiting...");
        // 主线程阻塞等待
        Object response = guardedObject.get();
        log.debug("get response: [{}] lines", ((List < String > ) response).size());
    }
}

执行结果

08:42:18.568 [main] c.TestGuardedObject - waiting...
08:42:23.312 [Thread-0] c.TestGuardedObject - download complete...
08:42:23.312 [main] c.TestGuardedObject - get response: [3] lines

3）带超时版 GuardedObject

class GuardedObjectV2 {
    private Object response;
    private final Object lock = new Object();
    public Object get(long millis) {
        synchronized(lock) {
            // 1) 记录最初时间
            long begin = System.currentTimeMillis();
            // 2) 已经经历的时间
            long timePassed = 0;
            while (response == null) {
                // 4) 假设 millis 是 1000，结果在 400 时唤醒了，那么还有 600 要等
                long waitTime = millis - timePassed;
                log.debug("waitTime: {}", waitTime);
                // 如果需要等待的时间小于等于0则退出循环
                if (waitTime <= 0) {
                    log.debug("break...");
                    break;
                }
                try {
                    lock.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 3) 如果提前被唤醒(如果response还为null则需要继续计算等待的时间)，这时已经经历的时				//	  间假设为 400
                timePassed = System.currentTimeMillis() - begin;
                log.debug("timePassed: {}, object is null {}",
                    timePassed, response == null);
            }
            return response;
        }
    }
    public void complete(Object response) {
        synchronized(lock) {
            // 条件满足，通知等待线程
            this.response = response;
            log.debug("notify...");
            lock.notifyAll();
        }
    }
}

测试没有超时

public static void main(String[] args) {
        GuardedObjectV2 v2 = new GuardedObjectV2();
        new Thread(() - > {
            sleep(1);
            // 提前唤醒主线程，由于传入null，所以主线程while循环依旧生效，继续阻塞
            v2.complete(null);
            sleep(1);
            // 此时传值，主线程的条件失效，退出阻塞状态
            v2.complete(Arrays.asList("a", "b", "c"));
        }).start();
        Object response = v2.get(2500);
        if (response != null) {
            log.debug("get response: [{}] lines", ((List < String > ) response).size());
        } else {
            log.debug("can't get response");
        }
    }

08:49:39.917 [main] c.GuardedObjectV2 - waitTime: 2500
08:49:40.917 [Thread-0] c.GuardedObjectV2 - notify...
08:49:40.917 [main] c.GuardedObjectV2 - timePassed: 1003, object is null true
08:49:40.917 [main] c.GuardedObjectV2 - waitTime: 1497
08:49:41.918 [Thread-0] c.GuardedObjectV2 - notify...
08:49:41.918 [main] c.GuardedObjectV2 - timePassed: 2004, object is null false
08:49:41.918 [main] c.TestGuardedObjectV2 - get response: [3] lines

测试超时

// 等待时间不足，主线程先获取锁，然后阻塞，1s后被Thread0唤醒，此时传值为空，所以主线程继续阻塞，阻塞时
// 间为498ms，当时间到了之后，主线程被唤醒，此时获取锁之后，由于等待时间为0，所以退出循环
List<String> lines = v2.get(1500);

08:47:54.963 [main] c.GuardedObjectV2 - waitTime: 1500
08:47:55.963 [Thread-0] c.GuardedObjectV2 - notify...
08:47:55.963 [main] c.GuardedObjectV2 - timePassed: 1002, object is null true
08:47:55.963 [main] c.GuardedObjectV2 - waitTime: 498
08:47:56.461 [main] c.GuardedObjectV2 - timePassed: 1500, object is null true
08:47:56.461 [main] c.GuardedObjectV2 - waitTime: 0
08:47:56.461 [main] c.GuardedObjectV2 - break...
08:47:56.461 [main] c.TestGuardedObjectV2 - can't get response
08:47:56.963 [Thread-0] c.GuardedObjectV2 - notify...

原理之 join

join是调用者轮询检查线程 alive 状态， 体现的是【保护性暂停】模式

t1.join() 等价于下面的代码

// 锁对象为t1线程
synchronized(t1) {
    // 调用者线程进入 t1 的 waitSet 等待, 直到 t1 运行结束，while循环是防止期间t1线程唤醒，但是t1线		// 程并没有执行完成所导致的虚假唤醒问题
    while (t1.isAlive()) {
        t1.wait(0);
    }
}

join源码

public final void join() throws InterruptedException {
        join(0);
    }

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

4）多任务版 GuardedObject

图中 Futures 就好比居民楼一层的信箱（每个信箱有房间编号），左侧的 t0，t2，t4 就好比等待邮件的居民，右 侧的 t1，t3，t5 就好比邮递员

如果需要在多个类之间使用 GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类， 这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理

原有类Guarded Object新增 id 用来标识 Guarded Object

    // 标识 Guarded Object
    private int id;
    public GuardedObject(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }

中间解耦类

class Mailboxes {
    private static Map < Integer, GuardedObject > boxes = new Hashtable < > ();
    private static int id = 1;
    // 产生唯一 id
    private static synchronized int generateId() {
        return id++;
    }
    public static GuardedObject getGuardedObject(int id) {
        return boxes.remove(id);
    }
    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }
    public static Set < Integer > getIds() {
        return boxes.keySet();
    }
}

业务相关类

class People extends Thread {
    @Override
    public void run() {
        // 收信
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        log.debug("开始收信 id:{}", guardedObject.getId());
        Object mail = guardedObject.get(5000);
        log.debug("收到信 id:{}, 内容:{}", guardedObject.getId(), mail);
    }
}

class Postman extends Thread {
    private int id;
    private String mail;
    public Postman(int id, String mail) {
        this.id = id;
        this.mail = mail;
    }
    @Override
    public void run() {
        GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
        log.debug("送信 id:{}, 内容:{}", id, mail);
        guardedObject.complete(mail);
    }
}

测试

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 3; i++) {
        new People().start();
    }
    Sleeper.sleep(1);
    for (Integer id: Mailboxes.getIds()) {
        new Postman(id, "内容" + id).start();
    }
}
10:35:05.689 c.People [Thread-1] - 开始收信 id:3
10:35:05.689 c.People [Thread-2] - 开始收信 id:1
10:35:05.689 c.People [Thread-0] - 开始收信 id:2
10:35:06.688 c.Postman [Thread-4] - 送信 id:2, 内容:内容2
10:35:06.688 c.Postman [Thread-5] - 送信 id:1, 内容:内容1
10:35:06.688 c.People [Thread-0] - 收到信 id:2, 内容:内容2
10:35:06.688 c.People [Thread-2] - 收到信 id:1, 内容:内容1
10:35:06.688 c.Postman [Thread-3] - 送信 id:3, 内容:内容3
10:35:06.689 c.People [Thread-1] - 收到信 id:3, 内容:内容3

模式之生产者消费者

1）定义

• 与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应

• 消费队列可以用来平衡生产和消费的线程资源

• 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据

• 消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据

• JDK 中各种阻塞队列，采用的就是这种模式

2）实现

class Message {
    private int id;
    private Object message;
    public Message(int id, Object message) {
        this.id = id;
        this.message = message;
    }
    public int getId() {
        return id;
    }
    public Object getMessage() {
        return message;
    }
}
class MessageQueue {
    private LinkedList <Message> queue;
    private int capacity;
    public MessageQueue(int capacity) {
        this.capacity = capacity;
        queue = new LinkedList <> ();
    }
    public Message take() {
        synchronized(queue) {
            while (queue.isEmpty()) {
                log.debug("没货了, wait");
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message message = queue.removeFirst();
            queue.notifyAll();
            return message;
        }
    }
    public void put(Message message) {
        synchronized(queue) {
            while (queue.size() == capacity) {
                log.debug("库存已达上限, wait");
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(message);
            queue.notifyAll();
        }
    }
}

3.9 Park & Unpark

基本使用

它们是 LockSupport 类中的方法

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

先 park 再 unpark

Thread t1 = new Thread(() -> {
    log.debug("start...");
    sleep(1);
    log.debug("park...");
    LockSupport.park();
    log.debug("resume...");
}, "t1");
t1.start();
sleep(2);
log.debug("unpark...");
LockSupport.unpark(t1);

输出

18:42:52.585 c.TestParkUnpark [t1] - start...
18:42:53.589 c.TestParkUnpark [t1] - park...
18:42:54.583 c.TestParkUnpark [main] - unpark...
18:42:54.583 c.TestParkUnpark [t1] - resume... 

先 unpark 再 park

Thread t1 = new Thread(() -> {
    log.debug("start...");
    sleep(2);
    log.debug("park...");
    LockSupport.park();
    log.debug("resume...");
}, "t1");
t1.start();
sleep(1);
log.debug("unpark...");
LockSupport.unpark(t1);

输出

18:43:50.765 c.TestParkUnpark [t1] - start...
18:43:51.764 c.TestParkUnpark [main] - unpark...
18:43:52.769 c.TestParkUnpark [t1] - park...
18:43:52.769 c.TestParkUnpark [t1] - resume...  // park失效，立马打印resume

特点

与 Object 的 wait & notify 相比

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

原理之 park & unpark

每个线程都有自己的一个 Parker 对象，由三部分组成 _counter ， _cond 和 _mutex

1. 当前线程调用 Unsafe.park() 方法
2. 检查 _counter ，本情况为 0，这时，获得 _mutex 互斥锁
3. 线程进入 _cond 条件变量阻塞
4. 设置 _counter = 0

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1
2. 唤醒 _cond 条件变量中的 Thread_0
3. Thread_0 恢复运行
4. 设置 _counter 为 0

当一开始调用upark方法时

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1
2. 当前线程调用 Unsafe.park() 方法
3. 检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行
4. 设置 _counter 为 0

3.10 重新理解线程状态转换

假设有线程 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.11 活跃性

死锁

一个线程需要同时获取多把锁，这时就容易发生死锁

t1 线程 获得 A对象 锁，接下来想获取 B对象 的锁 t2 线程 获得 B对象 锁，接下来想获取 A对象 的锁 例：

@Slf4j
public class DeadLockTest {
    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 {
                    Thread.sleep(1000);
                } 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 {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(A) {
                    log.debug("lock A");
                    log.debug("操作...");
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

结果：双方都在等对面释放锁

12:22:06.962 [t2] c.TestDeadLock - lock B
12:22:06.962 [t1] c.TestDeadLock - lock A

解决：按顺序加锁即可解决，比如t2线程也先去获取A锁，然后再去获取B锁

定位死锁

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

cmd > jps
17360 RemoteMavenServer36
16900 Launcher
17268
8404 KotlinCompileDaemon
1756 DeadLockTest
2892 Jps

用jstack定位死锁，一般死锁信息在最后面

cmd > jstack 1756
2024-08-25 12:24:06
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.192-b12 mixed mode):

"DestroyJavaVM" #14 prio=5 os_prio=0 tid=0x00000000035a4000 nid=0x25a4 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"t2" #13 prio=5 os_prio=0 tid=0x000000001d970000 nid=0x1b8 waiting for monitor entry [0x000000001e2af000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.zhou.test.DeadLockTest.lambda$main$1(DeadLockTest.java:33)
        - waiting to lock <0x000000078168b0e8> (a java.lang.Object)
        - locked <0x000000078168b0f8> (a java.lang.Object)
        at com.zhou.test.DeadLockTest$$Lambda$2/186276003.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"t1" #12 prio=5 os_prio=0 tid=0x000000001d96f800 nid=0x278c waiting for monitor entry [0x000000001e1af000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.zhou.test.DeadLockTest.lambda$main$0(DeadLockTest.java:19)
        - waiting to lock <0x000000078168b0f8> (a java.lang.Object)
        - locked <0x000000078168b0e8> (a java.lang.Object)
        at com.zhou.test.DeadLockTest$$Lambda$1/1232367853.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

// 略去部分输出

Found one Java-level deadlock:
=============================
"t2":
  waiting to lock monitor 0x000000001aac14c8 (object 0x000000078168b0e8, a java.lang.Object),
  which is held by "t1"
"t1":
  waiting to lock monitor 0x000000001aac2e38 (object 0x000000078168b0f8, a java.lang.Object),
  which is held by "t2"

Java stack information for the threads listed above:
===================================================
"t2":
        at com.zhou.test.DeadLockTest.lambda$main$1(DeadLockTest.java:33)
        - waiting to lock <0x000000078168b0e8> (a java.lang.Object)
        - locked <0x000000078168b0f8> (a java.lang.Object)
        at com.zhou.test.DeadLockTest$$Lambda$2/186276003.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)
"t1":
        at com.zhou.test.DeadLockTest.lambda$main$0(DeadLockTest.java:19)
        - waiting to lock <0x000000078168b0f8> (a java.lang.Object)
        - locked <0x000000078168b0e8> (a java.lang.Object)
        at com.zhou.test.DeadLockTest$$Lambda$1/1232367853.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

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

哲学家就餐问题

有五位哲学家，围坐在圆桌旁。

• 他们只做两件事，思考和吃饭，思考一会吃口饭，吃完饭后接着思考
• 吃饭时要用两根筷子吃，桌上共有 5 根筷子，每位哲学家左右手边各有一根筷子。
• 如果筷子被身边的人拿着，自己就得等待

筷子类

class Chopstick {
    String name;

    public Chopstick(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

哲学家类

@Slf4j
public class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @SneakyThrows
    private void eat() {
        log.debug("eating...");
        Thread.sleep(1000);
    }

    @Override
    public void run() {
        while (true) {
            // 获得左手筷子
            synchronized (left) {
                // 获得右手筷子
                synchronized (right) {
                    // 吃饭
                    eat();
                }
                // 放下右手筷子
            }
            // 放下左手筷子
        }
    }

    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("1");
        Chopstick c2 = new Chopstick("2");
        Chopstick c3 = new Chopstick("3");
        Chopstick c4 = new Chopstick("4");
        Chopstick c5 = new Chopstick("5");
        new Philosopher("苏格拉底", c1, c2).start();
        new Philosopher("柏拉图", c2, c3).start();
        new Philosopher("亚里士多德", c3, c4).start();
        new Philosopher("赫拉克利特", c4, c5).start();
        new Philosopher("阿基米德", c5, c1).start();
    }
}

执行不多会，就执行不下去了

12:33:40.084 [苏格拉底] DEBUG com.zhou.entity.Philosopher - eating...
12:33:40.084 [亚里士多德] DEBUG com.zhou.entity.Philosopher - eating...
12:33:41.084 [阿基米德] DEBUG com.zhou.entity.Philosopher - eating...

使用 jconsole工具（win+r然后输入jconsole）的检测死锁功能，发现

名称: 阿基米德
状态: com.zhou.entity.Chopstick@158b2946上的BLOCKED, 拥有者: 苏格拉底
总阻止数: 2, 总等待数: 1

堆栈跟踪: 
com.zhou.entity.Philosopher.run(Philosopher.java:31)
   - 已锁定 com.zhou.entity.Chopstick@3226eea7
--------------------------------------------------------------------------
名称: 苏格拉底
状态: com.zhou.entity.Chopstick@190970d1上的BLOCKED, 拥有者: 柏拉图
总阻止数: 6, 总等待数: 1

堆栈跟踪: 
com.zhou.entity.Philosopher.run(Philosopher.java:31)
   - 已锁定 com.zhou.entity.Chopstick@158b2946
--------------------------------------------------------------------------
名称: 柏拉图
状态: com.zhou.entity.Chopstick@7d817750上的BLOCKED, 拥有者: 亚里士多德
总阻止数: 2, 总等待数: 0

堆栈跟踪: 
com.zhou.entity.Philosopher.run(Philosopher.java:31)
   - 已锁定 com.zhou.entity.Chopstick@190970d1
--------------------------------------------------------------------------
名称: 亚里士多德
状态: com.zhou.entity.Chopstick@7bed004d上的BLOCKED, 拥有者: 赫拉克利特
总阻止数: 11, 总等待数: 2

堆栈跟踪: 
com.zhou.entity.Philosopher.run(Philosopher.java:31)
   - 已锁定 com.zhou.entity.Chopstick@7d817750
--------------------------------------------------------------------------
名称: 赫拉克利特
状态: com.zhou.entity.Chopstick@3226eea7上的BLOCKED, 拥有者: 阿基米德
总阻止数: 2, 总等待数: 0

堆栈跟踪: 
com.zhou.entity.Philosopher.run(Philosopher.java:31)
   - 已锁定 com.zhou.entity.Chopstick@7bed004d

这种线程没有按预期结束，执行不下去的情况，归类为**【活跃性】问题，除了死锁以外，还有活锁和饥饿者**两种情况

活锁

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

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) {
                sleep(0.2);
                count--;
                log.debug("count: {}", count);
            }
        }, "t1").start();
        new Thread(() - > {
            // 期望超过 20 退出循环
            while (count < 20) {
                sleep(0.2);
                count++;
                log.debug("count: {}", count);
            }
        }, "t2").start();
    }
}

饥饿

指一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束

3.12 ReentrantLock

相对于 synchronized 它具备如下特点

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

与 synchronized 一样，都支持可重入

基本语法

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

可重入

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

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
    method1();
}
public static void method1() {
    lock.lock();
    try {
        log.debug("execute method1");
        method2();
    } finally {
        lock.unlock();
    }
}
public static void method2() {
    lock.lock();
    try {
        log.debug("execute method2");
        method3();
    } finally {
        lock.unlock();
    }
}
public static void method3() {
    lock.lock();
    try {
        log.debug("execute method3");
    } finally {
        lock.unlock();
    }
}

输出

17:59:11.862 [main] c.TestReentrant - execute method1
17:59:11.865 [main] c.TestReentrant - execute method2
17:59:11.865 [main] c.TestReentrant - execute method3 

可打断

如果获取不了锁，可以打断该线程，不进行锁的获取，而synchronized不可打断只会死等，直到获取锁

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 {
    sleep(1);
    t1.interrupt();
    log.debug("执行打断");
} finally {
    lock.unlock();
}

输出

18:02:40.520 [main] c.TestInterrupt - 获得了锁
18:02:40.524 [t1] c.TestInterrupt - 启动...
18:02:41.530 [main] c.TestInterrupt - 执行打断
java.lang.InterruptedException
 at
java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchr
onizer.java:898)
 at
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchron
izer.java:1222)
 at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
 at cn.itcast.n4.reentrant.TestInterrupt.lambda$main$0(TestInterrupt.java:17)
 at java.lang.Thread.run(Thread.java:748)
18:02:41.532 [t1] c.TestInterrupt - 等锁的过程中被打断

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

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() - > {
    log.debug("启动...");
    lock.lock();
    try {
        log.debug("获得了锁");
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(1);
    t1.interrupt();
    log.debug("执行打断");
    sleep(1);
} finally {
    log.debug("释放了锁");
    lock.unlock();
}

输出

18:06:56.261 [main] c.TestInterrupt - 获得了锁
18:06:56.265 [t1] c.TestInterrupt - 启动...
18:06:57.266 [main] c.TestInterrupt - 执行打断 // 这时 t1 并没有被真正打断, 而是仍继续等待锁
18:06:58.267 [main] c.TestInterrupt - 释放了锁
18:06:58.267 [t1] c.TestInterrupt - 获得了锁

锁超时

调用tryLock()方法，如果没有获取锁会立刻失败

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 {
    sleep(2);
} finally {
    lock.unlock();
}

输出

18:15:02.918 [main] c.TestTimeout - 获得了锁
18:15:02.921 [t1] c.TestTimeout - 启动...
18:15:02.921 [t1] c.TestTimeout - 获取立刻失败，返回

超时失败

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 {
    sleep(2);
} finally {
    lock.unlock();
}

输出

18:19:40.537 [main] c.TestTimeout - 获得了锁
18:19:40.544 [t1] c.TestTimeout - 启动...
18:19:41.547 [t1] c.TestTimeout - 获取等待 1s 后失败，返回

使用 tryLock 解决哲学家就餐问题：如果第二把锁没获取到，就会释放掉第一把锁

class Chopstick extends ReentrantLock {
    String name;

    public Chopstick(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

@Slf4j
class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if (right.tryLock()) {
                        try {
                            eat();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock();
                }
            }
        }
    }

    @SneakyThrows
    private void eat() {
        log.debug("eating...");
        Thread.sleep(1000);
    }

    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("1");
        Chopstick c2 = new Chopstick("2");
        Chopstick c3 = new Chopstick("3");
        Chopstick c4 = new Chopstick("4");
        Chopstick c5 = new Chopstick("5");
        new Philosopher("苏格拉底", c1, c2).start();
        new Philosopher("柏拉图", c2, c3).start();
        new Philosopher("亚里士多德", c3, c4).start();
        new Philosopher("赫拉克利特", c4, c5).start();
        new Philosopher("阿基米德", c5, c1).start();
    }
}

程序可以一直执行下去，解决了死锁问题

公平锁

ReentrantLock 默认是不公平的

ReentrantLock lock = new ReentrantLock(false);
lock.lock();
for (int i = 0; i < 500; i++) {
    new Thread(() - > {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " running...");
        } finally {
            lock.unlock();
        }
    }, "t" + i).start();
}
// 1s 之后去争抢锁
Thread.sleep(1000);
new Thread(() - > {
    System.out.println(Thread.currentThread().getName() + " start...");
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + " running...");
    } finally {
        lock.unlock();
    }
}, "强行插入").start();
lock.unlock();

强行插入，有机会在中间输出

注意：该实验不一定总能复现

t39 running...
t40 running...
t41 running...
t42 running...
t43 running...
强行插入 start...
强行插入 running...
t44 running...
t45 running...
t46 running...
t47 running...
t49 running... 

改为公平锁后：ReentrantLock lock = new ReentrantLock(true);

强行插入，总是在最后输出

t465 running...
t464 running...
t477 running...
t442 running...
t468 running...
t493 running...
t482 running...
t485 running...
t481 running...
强行插入 running...

公平锁一般没有必要，会降低并发度

条件变量

synchronized 中也有条件变量，就是Monitor对象的waitSet ，当条件不满足时进入 waitSet 等待

ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

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

使用要点：

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

示例：

@Slf4j
public class ReentrantLockTest {
    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();
        Thread.sleep(1000);
        sendBreakfast();
        Thread.sleep(1000);
        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();
        }
    }
}

输出

13:16:52.947 [main] DEBUG com.zhou.test.ReentrantLockTest - 送早餐来了
13:16:52.947 [Thread-1] DEBUG com.zhou.test.ReentrantLockTest - 等到了它的早餐
13:16:53.952 [main] DEBUG com.zhou.test.ReentrantLockTest - 送烟来了
13:16:53.952 [Thread-0] DEBUG com.zhou.test.ReentrantLockTest - 等到了它的烟

3.13 同步模式之顺序控制

1.固定运行顺序

比如，必须先 2 后 1 打印

1.1 wait notify 版

// 用来同步的对象
static Object obj = new Object();
// t2 运行标记， 代表 t2 是否执行过
static boolean t2runed = false;
public static void main(String[] args) {
    Thread t1 = new Thread(() - > {
        synchronized(obj) {
            // 如果 t2 没有执行过
            while (!t2runed) {
                try {
                    // t1 先等一会
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(1);
    });
    Thread t2 = new Thread(() - > {
        System.out.println(2);
        synchronized(obj) {
            // 修改运行标记
            t2runed = true;
            // 通知 obj 上等待的线程（可能有多个，因此需要用 notifyAll）
            obj.notifyAll();
        }
    });
    t1.start();
    t2.start();
}

1.2 Park Unpark 版

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

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

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

Thread t1 = new Thread(() - > {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {}
    // 当没有『许可』时，当前线程暂停运行；有『许可』时，用掉这个『许可』，当前线程恢复运行
    LockSupport.park();
    System.out.println("1");
});
Thread t2 = new Thread(() - > {
    System.out.println("2");
    // 给线程 t1 发放『许可』（多次连续调用 unpark 只会发放一个『许可』）
    LockSupport.unpark(t1);
});
t1.start();
t2.start();

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

2. 交替输出

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

2.1 wait notify 版

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();
            }
        }
    }
    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();
    }
}

2.2 Lock 条件变量版

@Slf4j
public 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();
                log.debug(str);
                next.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                this.unlock();
            }
        }
    }

    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);
    }
}

注意：该实现没有考虑 a，b，c 线程都就绪再开始

2.3 Park Unpark 版

class SyncPark {
    private int loopNumber;
    private Thread[] threads;

    public SyncPark(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    public void setThreads(Thread... threads) {
        this.threads = threads;
    }

    public void print(String str) {
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();
            System.out.print(str);
            LockSupport.unpark(nextThread());
        }
    }

    private Thread nextThread() {
        Thread current = Thread.currentThread();
        int index = 0;
        for (int i = 0; i < threads.length; i++) {
            if (threads[i] == current) {
                index = i;
                break;
            }
        }
        if (index < threads.length - 1) {
            return threads[index + 1];
        } else {
            return threads[0];
        }
    }

    public void start() {
        for (Thread thread : threads) {
            thread.start();
        }
        LockSupport.unpark(threads[0]);
    }

    public static void main(String[] args) {
        SyncPark syncPark = new SyncPark(5);
        Thread t1 = new Thread(() -> {
            syncPark.print("a");
        });
        Thread t2 = new Thread(() -> {
            syncPark.print("b");
        });
        Thread t3 = new Thread(() -> {
            syncPark.print("c\n");
        });
        syncPark.setThreads(t1, t2, t3);
        syncPark.start();

    }
}