4.共享模型之管程

4.1 共享带来的问题

Java的体现

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/6 13:00*/
@Slf4j
public class Test14 {static int i = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for(int j = 0; j < 5000; j++) {i++;}});Thread t2 = new Thread(()->{for(int j = 0; j < 5000; j++) {i--;}});t1.start();t2.start();t1.join();t2.join();System.out.println(i);}
}

结果

问题分析

以上的结果可能是正数、负数、零。为什么呢？因为 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 行代码是顺序执行（不会交错）没有问题：

但是多线程下可能会出现问题

临界区 Critical Section

• 一个程序运行多个线程本身是没有问题的

• 问题出在多个线程访问共享资源

• • 多个线程读共享资源其实也没有问题
  • 在多个线程对共享资源读写操作时发生指令交错，就会出现问题

• 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

例如

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

竞态条件 Race Condition

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

4.2 synchronized 解决方案

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

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

synchronized

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/6 13:00*/
@Slf4j
public class Test14 {static int i = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()-> {for(int j = 0; j < 5000; j++) {synchronized (Test14.class) {i++;}}});Thread t2 = new Thread(()->{for(int j = 0; j < 5000; j++) {synchronized (Test14.class) {i--;}}});t1.start();t2.start();t1.join();t2.join();System.out.println(i);}
}

图分析

思考

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

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

面向对象改进

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

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/6 13:00*/
@Slf4j
public class Test14 {static Object o1 = new Object();static Object o2 = new Object();static int i = 0;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();}});Thread t2 = new Thread(()->{for(int j = 0; j < 5000; j++) {room.decrement();}});t1.start();t2.start();t1.join();t2.join();System.out.println(room.getValue());}
}class Room{int value = 0;public void increment(){synchronized (this) {value++;}}public void decrement(){synchronized (this) {value--;}}public int getValue(){synchronized (this) {return value;}}
}

4.3 方法上的synchronized

锁住的是this

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/6 13:00*/
@Slf4j
public class Test14 {static Object o1 = new Object();static Object o2 = new Object();static int i = 0;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();}});Thread t2 = new Thread(()->{for(int j = 0; j < 5000; j++) {room.decrement();}});t1.start();t2.start();t1.join();t2.join();System.out.println(room.getValue());}
}class Room{int value = 0;public synchronized void increment(){value++;}public synchronized void decrement(){value--;}public synchronized int getValue(){return value;}
}

加在静态方法上锁的是类对象O.class

不加synchronized的方法

不加synchronized的方法就好比不遵守规则的人，不老实排队

“线程八锁”

情况1：12或21

@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

sleep是不会释放锁

@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

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

@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

@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

@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

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

4.4 变量的线程安全分析

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

• 如果他们没有共享，则线程完全

• 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

• • 如果只有读操作，线程安全
  • 如果有读写操作，则这段代码块属于临界区，需要考虑线程安全

局部变量是否线程安全？

• 局部变量是线程安全

• 但局部变量引用的对象未必

• • 如果该对象没有逃离方法的作用范围，它是线程安全的
  • 如果该对象逃离方法的作用范围，需要考虑线程安全

局部变量线程安全分析

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

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

反编译文件

public static void test1();descriptor: ()Vflags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=1, args_size=00: 			bipush 			102: 			istore_03: 			iinc			 0, 16: 			returnLineNumberTable:line 10: 0line 11: 3line 12: 6LocalVariableTable:Start Length Slot Name Signature3 		4 		0 		i 		I

常见线程安全类

• String
• Integer
• StringBuffer
• Random
• Vector
• Hashtable
• Java.util.concurrent包下的所有类

多个线程调用它们同一个实例的某个方法时，是线程安全的

• 它们的每个方法是原子的
• 但注意它们多个方法的组合不是原子的

不可变线程安全性

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

4.5 Monitor概念

Java对象头

以32位虚拟机为例

普通对象

数组对象

其中Mark Word结构

64位虚拟机Mark Word

Monitor

Monitor被翻译为监视器或管程

每个Java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁之后，该对象头的Mark Work中就被设置指向Monitor对象指针。

• 刚开始Monitor中Owner为null
• 当线程1进入临界区，需要拿到obj的锁，就会根据obj对象的Mark Word找到对应的Monitor，看Owner是否为null
• 如果为null，则将Owner指向线程1，表示线程1拿到锁
• 当线程2进入临界区的时候，发现Owner不为null，就会被添加到EntryList中，变成BLOCKED状态
• 等待线程1释放锁，也就是使该Owner为null时看EntryList中的哪个线程会拿到锁。

synchronized

对应的字节码文件为

4.6 synchronized原理进阶

1.1. 轻量级锁

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

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

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

static final Object obj = new Object();
public static void method1(){synchronized(obj){// 同步块amethod2();}
}
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的值恢复给对象头

• • 成功，说明解锁成功
  • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁的解锁流程

1.2. 锁膨胀

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

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

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

• 这时Thread-1加轻量级锁失败，进入锁膨胀流程

• • 即为Object对象申请Monitor锁，让Object指向重量级锁的地址
  • 然后自己进入Monitor的EntryList BlOCKED

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

1.3. 自旋优化

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

自旋重试成功的情况：

自旋重试失败的情况：

• 在Java6之后自旋锁是自适应的，比如对象刚刚的一次自选操作成功过，那么认为这次自旋成功的可能性比较高，会多尝试几次，反之，则少尝试几次
• 自旋会占用cpu时间，单核cpu自旋就是浪费时间，多核cpu才能发挥出性能优势
• Java7以后不能控制是否开启自旋功能

1.4. 偏向锁

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

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

列如

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

图解

1.4.1. 偏向状态

回忆以下对象头格式

一个对象创建时：

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

1）测试延迟特性

2）测试偏向锁

3)测试禁用

4）测试hashCode

1.4.2. 撤销-调用对象hashCode

调用了对象的hashCode，但偏向锁的对象MarkWord中存储的是线程id，如果调用hashCode会导致偏向锁被撤销

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

1.4.3. 撤销-其它线程使用对象

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

1.4.4. 撤销-调用wait/notify

1.4.5. 批量重偏向

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

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

1.4.6. 批量撤销

当撤销偏向锁阈值超过40次后，jvm会这样觉得，我自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

1.4.7. 锁消除

4.7 原理之wait/notify

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

API介绍

• obj.wait()让进入object监视器的线程到waitSet等待
• obj.wait(long timeout)最多等待timeout毫秒
• obj.notify()在object上正在waitSet等待的线程中挑一个唤醒
• obj.notifyAll()让object上正在waitSet等待的线程全部唤醒

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

4.8 wait notify的正确姿势

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

• sleep是Thread方法，而wait是Object的方法
• sleep不需要强制更synchronized配合使用，但wait需要跟synchronized一起使用
• sleep在睡眠的同时不会释放锁，但wait在等待的时候会释放锁
• 它们状态TIMED_WAITING

Step1

import lombok.extern.slf4j.Slf4j;
import static java.lang.Thread.sleep;/*** @author xc* @date 2023/5/7 23:11*/
@Slf4j
public class Test17 {static final Object room = new Object();static boolean hasCigarette = false;static boolean hasTakeout = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {synchronized (room) {log.debug("有烟没？[{}]", hasCigarette);if (!hasCigarette) {log.debug("没烟，先歇会！");try {sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}}log.debug("有烟没？[{}]", hasCigarette);if (hasCigarette) {log.debug("可以开始干活了");}}}, "小南").start();for (int i = 0; i < 5; i++) {new Thread(() -> {synchronized (room) {log.debug("可以开始干活了");}}, "其它人").start();}sleep(1);new Thread(() -> {// 这里能不能加 synchronized (room)？hasCigarette = true;log.debug("烟到了噢！");}, "送烟的").start();}
}

输出

• 其它干活的线程都要一直阻塞，效率太低
• 小南线程必须睡足2s后才能醒来，就算烟提前送到，也无法立即醒来
• 加了synchronized(room)后，就好比小南在里面反锁门睡觉，烟根本没法送进门，main没加synchronized就好比main线程是翻窗户进来的
• 解决方法，使用wait-notify机制

Step2

import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author xc* @date 2023/5/7 23:11*/
@Slf4j
public class Test17 {static final Object room = new Object();static boolean hasCigarette = false;static boolean hasTakeout = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {synchronized (room) {log.debug("有烟没？[{}]", hasCigarette);if (!hasCigarette) {log.debug("没烟，先歇会！");try {room.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}log.debug("有烟没？[{}]", hasCigarette);if (hasCigarette) {log.debug("可以开始干活了");}}}, "小南").start();for (int i = 0; i < 5; i++) {new Thread(() -> {synchronized (room) {log.debug("可以开始干活了");}}, "其它人").start();}sleep(1);new Thread(() -> {// 这里能不能加 synchronized (room)？synchronized (room) {hasCigarette = true;log.debug("烟到了噢！");room.notify();}}, "送烟的").start();}
}

结果

• 解决了其它干活的线程阻塞的问题
• 但如果由其它线程也在等待条件呢？

Step3

import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author xc* @date 2023/5/7 23:11*/
@Slf4j
public class Test17 {static final Object room = new Object();static boolean hasCigarette = false;static boolean hasTakeout = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {synchronized (room) {log.debug("有烟没？[{}]", hasCigarette);if (!hasCigarette) {log.debug("没烟，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("有烟没？[{}]", hasCigarette);if (hasCigarette) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小南").start();new Thread(() -> {synchronized (room) {Thread thread = Thread.currentThread();log.debug("外卖送到没？[{}]", hasTakeout);if (!hasTakeout) {log.debug("没外卖，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("外卖送到没？[{}]", hasTakeout);if (hasTakeout) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小女").start();sleep(1);new Thread(() -> {synchronized (room) {hasTakeout = true;log.debug("外卖到了噢！");room.notify();}}, "送外卖的").start();}
}

结果

Step4

import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author xc* @date 2023/5/7 23:11*/
@Slf4j
public class Test17 {static final Object room = new Object();static boolean hasCigarette = false;static boolean hasTakeout = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {synchronized (room) {log.debug("有烟没？[{}]", hasCigarette);if (!hasCigarette) {log.debug("没烟，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("有烟没？[{}]", hasCigarette);if (hasCigarette) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小南").start();new Thread(() -> {synchronized (room) {Thread thread = Thread.currentThread();log.debug("外卖送到没？[{}]", hasTakeout);if (!hasTakeout) {log.debug("没外卖，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("外卖送到没？[{}]", hasTakeout);if (hasTakeout) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小女").start();sleep(1);new Thread(() -> {synchronized (room) {hasTakeout = true;log.debug("外卖到了噢！");room.notifyAll();}}, "送外卖的").start();}
}

结果

• 用notifyAll仅解决某个线程的唤醒问题，但使用if+wait判断仅有一次机会，一但条件不成立，就没有重新判断的机会了
• 解决方法，用while+wait，但条件不成立，再次wait

Step5

import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author xc* @date 2023/5/7 23:11*/
@Slf4j
public class Test17 {static final Object room = new Object();static boolean hasCigarette = false;static boolean hasTakeout = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {synchronized (room) {log.debug("有烟没？[{}]", hasCigarette);while (!hasCigarette) {log.debug("没烟，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("有烟没？[{}]", hasCigarette);if (hasCigarette) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小南").start();new Thread(() -> {synchronized (room) {Thread thread = Thread.currentThread();log.debug("外卖送到没？[{}]", hasTakeout);if (!hasTakeout) {log.debug("没外卖，先歇会！");try {room.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("外卖送到没？[{}]", hasTakeout);if (hasTakeout) {log.debug("可以开始干活了");} else {log.debug("没干成活...");}}}, "小女").start();sleep(1);new Thread(() -> {synchronized (room) {hasTakeout = true;log.debug("外卖到了噢！");room.notifyAll();}}, "送外卖的").start();}
}

结果

使用套路

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

同步模式之保护性暂停

1. 定义

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

要点：

• 有一个结果需要从一个线程传递到另一个线程，让它们关联共一个GuardedObject
• 如果有结果不断从一个线程到另一个线程那么可以使用消息队列
• JDK中，join的实现，Future的实现，采用的就是此模式
• 因为要等待另一方的结果，因此归类到同步模式

2. 实现

import lombok.extern.slf4j.Slf4j;import java.io.IOException;
import java.util.List;/*** @author xc* @date 2023/5/8 13:08*/
@Slf4j
class Test20{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());}}
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();}}
}

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);if (waitTime <= 0) {log.debug("break...");break;}try {lock.wait(waitTime);} catch (InterruptedException e) {e.printStackTrace();}
// 3) 如果提前被唤醒，这时已经经历的时间假设为 400timePassed = 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();}}
}

异步模式之生产者/消费者

定义

要点

• 与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
• 消费队列可以用来平衡生产和消费的线程资源
• 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果
• 消息队列是有容量限制的，满时不会再加入数据，空时不会在小号数据
• JDK中各种阻塞队列，采用的就是这种模式

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

特点

与Object的wait & notify相比

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

原理之park & unpark

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

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

4.10 重新理解线程状态转换

情况1 NEW --> RUNNABLE

• 当调用t.start()方法时，由NEW --> RUNNABLE

情况2 RUNNABLE <–> WAITING

t线程用synchronized(obj)获取了对象锁后

• 调用obj.wait()方法时，t线程从RUNNABLE --> WAITING

• 调用obj.notify()，obj.notifyAll()，obj.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

4.11 多把锁

多把不相干的锁

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

import lombok.extern.slf4j.Slf4j;import java.io.IOException;
import java.util.List;/*** @author xc* @date 2023/5/8 13:08*/
@Slf4j
public class Test20{public static void main(String[] args) throws InterruptedException {BigRoom bigRoom = new BigRoom();new Thread(()->{try {bigRoom.sleep();} catch (InterruptedException e) {throw new RuntimeException(e);}},"小南").start();new Thread(()->{try {bigRoom.study();} catch (InterruptedException e) {throw new RuntimeException(e);}},"小女").start();}}
@Slf4j
class BigRoom {public void sleep() throws InterruptedException {synchronized (this) {log.debug("sleeping 2 小时");Thread.sleep(2000);}}public void study() throws InterruptedException {synchronized (this) {log.debug("study 1 小时");Thread.sleep(1000);}}
}

结果

改进

import lombok.extern.slf4j.Slf4j;import java.io.IOException;
import java.util.List;/*** @author xc* @date 2023/5/8 13:08*/
@Slf4j
public class Test20{public static void main(String[] args) throws InterruptedException {BigRoom bigRoom = new BigRoom();new Thread(()->{try {bigRoom.sleep();} catch (InterruptedException e) {throw new RuntimeException(e);}},"小南").start();new Thread(()->{try {bigRoom.study();} catch (InterruptedException e) {throw new RuntimeException(e);}},"小女").start();}}
@Slf4j
class BigRoom {// 多把锁互不影响private Object sleepLock = new Object();private Object studyLock = new Object();public void sleep() throws InterruptedException {synchronized (sleepLock) {log.debug("sleeping 2 小时");Thread.sleep(2000);}}public void study() throws InterruptedException {synchronized (studyLock) {log.debug("study 1 小时");Thread.sleep(1000);}}
}

结果

4.12 活跃性

死锁

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

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/8 16:38*/
@Slf4j
public class Test21 {private static Object a = new Object();private static Object b = new Object();public static void main(String[] args) {new Thread(()->{synchronized (a) {try {Thread.sleep(50);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (b) {log.debug("a操作");}}}).start();new Thread(()->{synchronized (b) {try {Thread.sleep(50);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (a) {log.debug("b操作");}}}).start();}
}

结果

一直不打印操作

定位死锁

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

哲学家就餐问题

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

活锁

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

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/8 16:38*/
@Slf4j
public class Test21 {static volatile int count = 10;private final Object lock = new Object();public static void main(String[] args) {new Thread(()->{while (count > 0) {try {Thread.sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}count--;log.debug(String.valueOf(count));}}).start();new Thread(()->{while (count < 20) {try {Thread.sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}count++;log.debug(String.valueOf(count));}}).start();}
}

饥饿

4.13 ReentrantLock

相对于synchronized它具备如下特点

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

与synchronized一样，都可以重入

基本语法

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

可重入

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.ReentrantLock;/*** @author xc* @date 2023/5/8 17:12*/
@Slf4j
public class Test22 {static ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {lock.lock();try {log.debug("进入m1");m1();} finally {lock.unlock();}}public static void m1(){lock.lock();try {log.debug("进入m2");m2();} finally {lock.unlock();}}public static void m2(){lock.lock();try {log.debug("进入m3");} finally {lock.unlock();}}
}

可打断

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.ReentrantLock;/*** @author xc* @date 2023/5/8 17:29*/
@Slf4j
public class Test23 {static ReentrantLock lock = new ReentrantLock();public static void main(String[] args) throws InterruptedException {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 {Thread.sleep(1000);t1.interrupt();log.debug("执行打断");} finally {lock.unlock();}}
}

结果

锁超时

超时失败

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;/*** @author xc* @date 2023/5/8 18:15*/
@Slf4j
public class Test24 {private static ReentrantLock lock = new ReentrantLock();public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{try {if (!lock.tryLock(2, TimeUnit.SECONDS)) {log.debug("获取不到锁");return;}} catch (InterruptedException e) {e.printStackTrace();log.debug("获取不到共享锁");return;}try {log.debug("获取到锁");} finally {lock.unlock();}},"t1");lock.lock();log.debug("获取到锁");t1.start();Thread.sleep(2000);lock.unlock();log.debug("释放锁");}
}

公平锁

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

条件变量

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

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

使用要点：

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

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;/*** @author xc* @date 2023/5/8 18:52*/
@Slf4j
public class Test25 {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();}}
}

同步模式之顺序控制

固定运行顺序

先打印2，再打印1

wait & notify

import lombok.extern.slf4j.Slf4j;/*** @author xc* @date 2023/5/8 19:05*/
@Slf4j
public class Test26 {private static Object o = new Object();private static boolean isPrint = false;public static void main(String[] args) {Thread t1 = new Thread(()->{synchronized (o){while (!isPrint) {try {o.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}log.debug("1");}});Thread t2 = new Thread(()->{synchronized (o){log.debug("2");isPrint = true;o.notify();}});t1.start();t2.start();}
}

park & unPark

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.LockSupport;/*** @author xc* @date 2023/5/8 19:05*/
@Slf4j
public class Test26 {private static Object o = new Object();private static boolean isPrint = false;public static void main(String[] args) {Thread t1 = new Thread(()->{LockSupport.park();log.debug("1");});Thread t2 = new Thread(()->{log.debug("2");isPrint = true;LockSupport.unpark(t1);});t1.start();t2.start();}
}

交替输出

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

wait & notify

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.LockSupport;/*** @author xc* @date 2023/5/8 19:05*/
@Slf4j
public class Test26 {public static void main(String[] args) {SyncWaitNotify syncWaitNotify = new SyncWaitNotify(1, 5);new Thread(() -> {syncWaitNotify.print(1, 2, "a");}).start();new Thread(() -> {syncWaitNotify.print(2, 3, "b");}).start();new Thread(() -> {syncWaitNotify.print(3, 1, "c");}).start();}
}
class SyncWaitNotify {private int flag;private int loopNumber;public SyncWaitNotify(int flag, int loopNumber) {this.flag = flag;this.loopNumber = loopNumber;}public void print(int waitFlag, int nextFlag, String str) {for (int i = 0; i < loopNumber; i++) {synchronized (this) {while (this.flag != waitFlag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.print(str);flag = nextFlag;this.notifyAll();}}}
}

Lock条件变量版

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/*** @author xc* @date 2023/5/8 19:57*/
@Slf4j
public class Test27 {public static void main(String[] args) {AwaitSignal as = new AwaitSignal(5);Condition aWaitSet = as.newCondition();Condition bWaitSet = as.newCondition();Condition cWaitSet = as.newCondition();new Thread(() -> {as.print("a", aWaitSet, bWaitSet);}).start();new Thread(() -> {as.print("b", bWaitSet, cWaitSet);}).start();new Thread(() -> {as.print("c", cWaitSet, aWaitSet);}).start();as.start(aWaitSet);}
}
@Slf4j
class AwaitSignal extends ReentrantLock {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();}}}// 循环次数private int loopNumber;public AwaitSignal(int loopNumber) {this.loopNumber = loopNumber;}
}

Park Unpark版

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.LockSupport;/*** @author xc* @date 2023/5/8 20:00*/
@Slf4j
public class Test28 {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();}
}
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]);}
}this.lock();try {current.await();log.debug(str);next.signal();} catch (InterruptedException e) {e.printStackTrace();} finally {this.unlock();}}}// 循环次数private int loopNumber;public AwaitSignal(int loopNumber) {this.loopNumber = loopNumber;}
}

Park Unpark版

import lombok.extern.slf4j.Slf4j;import java.util.concurrent.locks.LockSupport;/*** @author xc* @date 2023/5/8 20:00*/
@Slf4j
public class Test28 {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();}
}
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]);}
}