第三章 - 共享模型之管程(四)

线程状态

重新理解线程状态转换 (重点)

假设有线程 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

@Slf4j(topic = "c.TestWaitNotify")
public class TestWaitNotify {final static Object obj = new Object();public static void main(String[] args) {new Thread(() -> {synchronized (obj) {log.debug("执行....");try {obj.wait(); // 让线程在obj上一直等待下去} catch (InterruptedException e) {e.printStackTrace();}log.debug("其它代码....");}},"t1").start();new Thread(() -> {synchronized (obj) {log.debug("执行....");try {obj.wait(); // 让线程在obj上一直等待下去} catch (InterruptedException e) {e.printStackTrace();}log.debug("其它代码....");}},"t2").start();// 主线程两秒后执行sleep(0.5);log.debug("唤醒 obj 上其它线程");synchronized (obj) {obj.notifyAll(); // 唤醒obj上所有等待线程}}
}

Monitor示意图：

示例调试步骤

• 设置3个断点

• 顺序执行代码，线程t1、t2都wait了，断点来到主线程的notifyAll( )

• 向下执行，主线程notifyAll( )唤醒所有waiting的线程，这些线程从锁对象obj的waitSet移动到EntryList竞争对象锁

• 主线程向下执行，出了synchronized块，释放了锁。t1、t2可以竞争锁。可以看到t2竞争锁成功，成为锁对象obj的owner，t1仍然在entryList中阻塞。

• t2线程向下执行，出了synchronized块，释放锁，t1线程拿到锁

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

多把锁

多把不相干的锁

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

代码示例

@Slf4j(topic = "c.BigRoomTest")
public class BigRoomTest {public static void main(String[] args) {BigRoom bigRoom = new BigRoom();new Thread(() -> {bigRoom.study();}, "小南").start();new Thread(() -> {bigRoom.sleep();}, "小女").start();}}@Slf4j(topic = "c.BigRoom")
class BigRoom {public void sleep() {synchronized (this) {log.debug("sleeping 2 小时");Sleeper.sleep(2);}}public void study() {synchronized (this) {log.debug("study 1 小时");Sleeper.sleep(1);}}}

改进方法：让小南, 小女获取不同的锁即可

@Slf4j(topic = "c.BigRoomTest")
public class BigRoomTest {public static void main(String[] args) {BigRoom bigRoom = new BigRoom();new Thread(() -> {bigRoom.study();}, "小南").start();new Thread(() -> {bigRoom.sleep();}, "小女").start();}}@Slf4j(topic = "c.BigRoom")
class BigRoom {private static final BigRoom bedRoom = new BigRoom(); //卧室private static final BigRoom studyRoom = new BigRoom(); //书房public void sleep() {synchronized (bedRoom) {log.debug("sleeping 2 小时");Sleeper.sleep(2);}}public void study() {synchronized (studyRoom) {log.debug("study 1 小时");Sleeper.sleep(1);}}}

• 将锁的粒度细分
  • 好处，是可以增强并发度
  • 坏处，如果一个线程需要同时获得多把锁，就容易发生死锁

活跃性

• 因为某种原因，使得代码一直无法执行完毕，这样的现象叫做 活跃性
• 活跃性相关的一系列问题都可以用 ReentrantLock 进行解决。

死锁 (重点)

• 有这样的情况：一个线程需要 同时获取多把锁，这时就容易发生死锁

线程1获取A对象锁, 线程2获取B对象锁; 此时线程1又想获取B对象锁, 线程2又想获取A对象锁; 它们都等着对象释放锁, 此时就称为死锁

@Slf4j(topic = "c.TestDeadLock")
public class TestDeadLock {public static void main(String[] args) {test1();}private static void test1() {Object A = new Object();Object B = new Object();Thread t1 = new Thread(() -> {synchronized (A) {log.debug("lock A");sleep(1);synchronized (B) {log.debug("lock B");log.debug("操作...");}}}, "t1");Thread t2 = new Thread(() -> {synchronized (B) {log.debug("lock B");sleep(0.5);synchronized (A) {log.debug("lock A");log.debug("操作...");}}}, "t2");t1.start();t2.start();}}

发生死锁的必要条件 (重点)

• 互斥条件
  • 在一段时间内，一种资源只能被一个进程所使用
• 请求和保持条件
  • 进程已经拥有了至少一种资源，同时又去申请其他资源。因为其他资源被别的进程所使用，该进程进入阻塞状态，并且不释放自己已有的资源
• 不可抢占条件
  • 进程对已获得的资源在未使用完成前不能被强占，只能在进程使用完后自己释放
• 循环等待条件
  • 发生死锁时，必然存在一个进程——资源的循环链。

定位死锁的方法

方式一、JPS + JStack 进程ID

• jps先找到JVM进程
• jstack 进程ID
  • 在Java控制台中的Terminal中输入 jps 指令可以查看正在运行中的进程ID，使用 jstack 进程ID 可以查看进程状态。

jps

jstack 59114

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

方式二、 jconsole检测死锁

哲学家就餐问题

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

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

代码示例

public class TestDeadLock {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();}}@Slf4j(topic = "c.Philosopher")
// 哲学家类
class Philosopher extends Thread {Chopstick left; // 左边的筷子Chopstick right; // 右边的筷子public Philosopher(String name, Chopstick left, Chopstick right) {super(name);this.left = left;this.right = right;}@Overridepublic void run() {while (true) {//　尝试获得左手筷子synchronized (left) {// 尝试获得右手筷子synchronized (right) {// 吃饭eat();}// 放下右手筷子}// 放下左手筷子}}private void eat() {log.debug("eating...");Sleeper.sleep(0.5);}
}// 筷子类
class Chopstick {String name;public Chopstick(String name) {this.name = name;}@Overridepublic String toString() {return "筷子{" + name + '}';}
}

执行一会儿，就不再执行下去了

• 使用 jconsole 检测死锁，发现

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

活锁

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

@Slf4j(topic = "c.TestLiveLock")
public class TestLiveLock {static volatile int count = 10;static final Object lock = new Object();public static void main(String[] args) {new Thread(() -> {// 期望减到 0 退出循环while (count > 0) {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 调度执行，也不能够结束，饥饿的情况不易演示，讲读写锁时会涉及饥饿问题
• 下面我讲一下我遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题

顺序加锁的解决方案

虽然不会发生死锁了，但是会发生饥饿

public class TestDeadLock {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("阿基米德", c1, c5).start();}
}

• 由之前的

new Philosopher("阿基米德", c5, c1).start();

• 改为了

new Philosopher("阿基米德", c1, c5).start();

• 可以看到，程序没有发生死锁，但可以看到有些线程根本没有机会执行

ReentrantLock (重点)

ReentrantLock 的特点 (synchronized不具备的)

• 支持可重入
  • 可重入锁是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此 有权利再次获取这把锁
• 可中断
  • lock.lockInterruptibly( ) : 可以被其他线程打断的中断锁
• 可以设置超时时间
  • lock.tryLock(时间) : 尝试获取锁对象, 如果超过了设置的时间, 还没有获取到锁, 此时就退出阻塞队列, 并释放掉自己拥有的锁
• 可以设置为公平锁
  • (先到先得) 默认是非公平, true为公平 new ReentrantLock(true)
• 支持多个条件变量( 有多个waitSet )
  • (可避免虚假唤醒) - lock.newCondition( )创建条件变量对象; 通过条件变量对象调用 await/signal方法, 等待/唤醒

基本语法

//获取ReentrantLock对象
private ReentrantLock lock = new ReentrantLock();
//加锁
lock.lock();
try {// 临界区
}finally {// 释放锁lock.unlock();
}

支持可重入

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

/*** @author xiexu* @create 2022-02-01 8:56 AM*/
@Slf4j(topic = "c.ReentrantTest")
public class ReentrantTest {// 获取ReentrantLock对象private static ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {// 如果有竞争就进入"阻塞队列"，一直等待着，不能被打断lock.lock();try {log.debug("entry main...");m1();} finally {lock.unlock();}}private static void m1() {lock.lock();try {log.debug("entry m1...");m2();} finally {lock.unlock();}}private static void m2() {lock.lock();try {log.debug("entry m2....");} finally {lock.unlock();}}}

可中断 (针对于lockInterruptibly( )方法获得的中断锁) 直接退出阻塞队列, 获取锁失败

synchronized 和 reentrantlock.lock( ) 的锁, 是不可被打断的; 也就是说别的线程已经获得了锁, 我的线程就需要一直等待下去，不能中断

• 可被中断的锁, 通过 lock.lockInterruptibly( ) 获取的锁对象, 可以通过调用阻塞线程的interrupt( ) 方法

• 如果某个线程处于阻塞状态，可以调用其interrupt方法让其停止阻塞，获得锁失败
  • 处于阻塞状态的线程，被打断了就不用阻塞了，直接停止运行
• 可中断的锁, 在一定程度上可以被动的减少死锁的概率, 之所以被动, 是因为我们需要手动调用阻塞线程的interrupt方法;

测试使用lock.lockInterruptibly()可以从阻塞队列中,打断

/*** 演示RenntrantLock中的可打断锁方法 lock.lockInterruptibly();** @author xiexu* @create 2022-02-01 10:38 AM*/
@Slf4j(topic = "c.ReentrantTest")
public class ReentrantTest {private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {log.debug("t1线程启动...");try {// 如果没有竞争那么此方法就会获取 lock 对象锁// 如果有竞争就进入阻塞队列，可以被其他线程用 interrupt 方法打断log.debug("尝试获得锁");lock.lockInterruptibly();} catch (InterruptedException e) {e.printStackTrace();log.debug("等锁的过程中被打断了，没有获得锁，返回"); //没有获得锁就不需要往下走了return;}try {log.debug("t1线程获得了锁");} finally {log.debug("t1线程释放了锁");lock.unlock();}}, "t1");// 主线程获得锁(此锁不可被打断)lock.lock();log.debug("main线程获得了锁");// 启动t1线程t1.start();try {Sleeper.sleep(1);log.debug("打断 t1 线程");t1.interrupt();            //打断t1线程} finally {lock.unlock();}}
}

测试使用lock.lock()不可以从阻塞队列中打断, 一直等待别的线程释放锁

@Slf4j(topic = "c.ReentrantTest")
public class ReentrantTest {private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {log.debug("t1线程启动...");log.debug("尝试获得锁");lock.lock();try {log.debug("t1线程获得了锁");} finally {log.debug("t1线程释放了锁");lock.unlock();}}, "t1");// 主线程获得锁(此锁不可被打断)lock.lock();log.debug("main线程获得了锁");// 启动t1线程t1.start();try {Sleeper.sleep(1);log.debug("打断 t1 线程");t1.interrupt();            //打断t1线程} finally {log.debug("main线程释放了锁");lock.unlock();}}
}

• lock( )锁不能被打断, 在主线程中调用t1.interrupt( ), 没用, 当主线程释放锁之后, t1线程获得了锁

锁超时 (lock.tryLock( )) 直接退出阻塞队列, 获取锁失败

防止无限制等待, 减少死锁

• 使用 lock.tryLock( ) 方法会返回获取锁是否成功。如果成功则返回true，反之则返回false。
• 并且tryLock方法可以设置指定等待时间，参数为：tryLock(long timeout, TimeUnit unit) , 其中timeout为最长等待时间，TimeUnit为时间单位
• 获取锁的过程中, 如果超过等待时间, 或者被打断, 就直接从阻塞队列移除, 此时获取锁就失败了, 不会一直阻塞着 ! (可以用来实现死锁问题)

不设置等待时间, 立即失败

/*** 演示RenntrantLock中的tryLock()** @author xiexu* @create 2022-02-01 10:38 AM*/
@Slf4j(topic = "c.ReentrantTest")
public class ReentrantTest {private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {log.debug("尝试获得锁");// 此时肯定获取失败, 因为主线程已经获得了锁对象if (!lock.tryLock()) {log.debug("获取不到锁，返回");return;}try {log.debug("获得到锁");} finally {log.debug("释放了锁");lock.unlock();}}, "t1");lock.lock(); // main线程先获得锁log.debug("获得到锁");t1.start();// 主线程2s之后才释放锁Sleeper.sleep(2);log.debug("释放了锁");lock.unlock();}}

设置等待时间, 超过等待时间还没有获得锁, 失败, 从阻塞队列中移除该线程

/*** 演示RenntrantLock中的tryLock(long mills), * 超过锁设置的等待时间或者被打断,就从阻塞队列移除** @author xiexu* @create 2022-02-01 10:38 AM*/
@Slf4j(topic = "c.ReentrantTest")
public class ReentrantTest {private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {log.debug("尝试获得锁");try {// 设置等待时间, 超过等待时间或者被打断, 都会获取锁失败; 退出阻塞队列if (!lock.tryLock(3, TimeUnit.SECONDS)) {log.debug("获取不到锁，返回");return;}} catch (InterruptedException e) {e.printStackTrace();log.debug("被打断了, 获取锁失败, 返回");return;}try {log.debug("获得到锁");} finally {log.debug("释放了锁");lock.unlock();}}, "t1");lock.lock(); // main线程先获得锁log.debug("获得到锁");t1.start();t1.interrupt(); // 打断t1线程// 主线程5s之后才释放锁Sleeper.sleep(5);lock.unlock();log.debug("释放了锁");}}

通过lock.tryLock( )来解决, 哲学家就餐问题 (重点)

lock.tryLock(时间) : 尝试获取锁对象, 如果超过了设置的时间, 还没有获取到锁, 此时就退出阻塞队列, 并释放掉自己拥有的锁

/*** 使用了ReentrantLock锁, 该类中有一个tryLock()方法, 在指定时间内获取不到锁对象, 就从阻塞队列移除,不用一直等待。* 当获取了左手边的筷子之后, 尝试获取右手边的筷子, 如果该筷子被其他哲学家占用, 获取失败, 此时就先把自己左手边的筷子,* 给释放掉. 这样就避免了死锁问题*/
@Slf4j(topic = "c.TestDeadLock")
public class TestDeadLock {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();}}@Slf4j(topic = "c.Philosopher")
// 哲学家类
class Philosopher extends Thread {Chopstick left; // 左边的筷子Chopstick right; // 右边的筷子public Philosopher(String name, Chopstick left, Chopstick right) {super(name);this.left = left;this.right = right;}@Overridepublic void run() {while (true) {// 获得了左手边筷子 (针对五个哲学家, 它们刚开始肯定都可获得左筷子)if (left.tryLock()) {try {// 此时发现它的right筷子被占用了, 使用tryLock(),// 尝试获取失败, 此时它就会将自己左筷子也释放掉// 临界区代码if (right.tryLock()) { //尝试获取右手边筷子, 如果获取失败, 则会释放左边的筷子try {eat();} finally {right.unlock();}}} finally {left.unlock(); //释放自己手里左手的筷子}}}}private void eat() {log.debug("eating...");Sleeper.sleep(0.5);}
}// 继承ReentrantLock, 让筷子类称为锁
class Chopstick extends ReentrantLock {String name;public Chopstick(String name) {this.name = name;}@Overridepublic String toString() {return "筷子{" + name + '}';}}

公平锁 new ReentrantLock(true)

• ReentrantLock默认是非公平锁, 但是可以指定为公平锁。
• 在线程获取锁失败，进入阻塞队列时，先进入的会在锁被释放后先获得锁。这样的获取方式就是公平的。
• 一般不要设置ReentrantLock为公平的, 会降低并发度
• Synchronized底层的Monitor锁就是不公平的, 和谁先进入阻塞队列是没有关系的。

//默认是不公平锁，需要在创建时指定为公平锁
ReentrantLock lock = new ReentrantLock(true);

什么是公平锁? 什么是非公平锁?

• 公平锁 (new ReentrantLock(true))
  • 公平锁, 可以把竞争的线程放在一个先进先出的阻塞队列上
  • 只要持有锁的线程执行完了, 唤醒阻塞队列中的下一个线程获取锁即可; 此时先进入阻塞队列的线程先获取到锁
• 非公平锁 (synchronized, new ReentrantLock( ))
  • 非公平锁, 当阻塞队列中已经有等待的线程A了, 此时后到的线程B, 先去尝试看能否获得到锁对象. 如果获取成功, 此时就不需要进入阻塞队列了. 这样以来后来的线程B就先获得到锁了
• 所以公平和非公平的区别就是 : 线程执行同步代码块时, 是否会去尝试获取锁, 如果会尝试获取锁, 那就是非公平的, 如果不会尝试获取锁, 直接进入阻塞队列, 再等待被唤醒, 那就是公平的

条件变量 (可避免虚假唤醒) - lock.newCondition( )创建条件变量对象; 通过条件变量对象调用await/signal方法, 等待/唤醒

• Synchronized 中也有条件变量，就是Monitor监视器中的 waitSet 等待集合，当条件不满足时进入waitSet 等待
• ReentrantLock 的条件变量比 synchronized 强大之处在于,它是支持多个条件变量。
  • synchronized 是那些不满足条件的线程都在一间休息室等通知; (此时会造成虚假唤醒)
  • 而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒的; (可以避免虚假唤醒)

使用流程

• await 前需要 获得锁
• await 执行后，会释放锁，进入 conditionObject (条件变量)中等待
• await 的线程被唤醒（或打断、或超时）去重新竞争 lock 锁
• 竞争 lock 锁成功后，从 await 后继续执行
• signal 方法用来唤醒某个条件变量(休息室)的某一个等待的线程
• signalAll 方法用来唤醒某个条件变量(休息室)中的所有线程

/*** ReentrantLock可以设置多个条件变量(多个休息室), 相对于synchronized底层monitor锁中waitSet** @author xiexu* @create 2022-02-03 10:18 AM*/
@Slf4j(topic = "c.ConditionVariable")
public class ConditionVariable {private static boolean hasCigarette = false;private static boolean hasTakeout = false;private static final ReentrantLock lock = new ReentrantLock();// 创建新的条件变量（休息室）// 等待烟的休息室static Condition waitCigaretteSet = lock.newCondition();// 等外卖的休息室static Condition waitTakeoutSet = lock.newCondition();public static void main(String[] args) {new Thread(() -> {lock.lock();try {log.debug("有烟没？[{}]", hasCigarette);while (!hasCigarette) {log.debug("没烟，先歇会！");try {// 此时小南进入到 等烟的休息室waitCigaretteSet.await();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("烟来咯, 可以开始干活了");} finally {lock.unlock();}}, "小南").start();new Thread(() -> {lock.lock();try {log.debug("外卖送到没？[{}]", hasTakeout);while (!hasTakeout) {log.debug("没外卖，先歇会！");try {// 此时小女进入到 等外卖的休息室waitTakeoutSet.await();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("外卖来咯, 可以开始干活了");} finally {lock.unlock();}}, "小女").start();Sleeper.sleep(1);new Thread(() -> {lock.lock();try {log.debug("送外卖的来咯~");hasTakeout = true;// 唤醒等外卖的小女线程waitTakeoutSet.signal();} finally {lock.unlock();}}, "送外卖的").start();Sleeper.sleep(1);new Thread(() -> {lock.lock();try {log.debug("送烟的来咯~");hasCigarette = true;// 唤醒等烟的小南线程waitCigaretteSet.signal();} finally {lock.unlock();}}, "送烟的").start();}}

同步模式之顺序控制

固定运行顺序

• 假如有两个线程, 线程A打印1, 线程B打印2.
• 要求: 程序先打印2, 再打印1

使用ReentrantLock的 await/signal

/*** 使用ReentrantLock的 await/sinal 来实现顺序打印 2, 1** @author xiexu* @create 2022-02-03 10:42 AM*/
@Slf4j(topic = "c.SyncPrintWaitTest")
public class SyncPrintWaitTest {public static final ReentrantLock lock = new ReentrantLock();public static Condition condition = lock.newCondition();// 表示 t2 线程是否运行过public static boolean t2Runned = false;public static void main(String[] args) {Thread t1 = new Thread(() -> {lock.lock();try {// 临界区while (!t2Runned) {try {condition.await();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("1");} finally {lock.unlock();}}, "t1");Thread t2 = new Thread(() -> {lock.lock();try {log.debug("2");t2Runned = true;condition.signal();} finally {lock.unlock();}}, "t2");t1.start();t2.start();}
}

Wait/Notify版本实现

/*** 使用wait/notify来实现顺序打印 2, 1** @author xiexu* @create 2022-02-03 10:30 AM*/
@Slf4j(topic = "c.SyncPrintWaitTest")
public class SyncPrintWaitTest {public static final Object lock = new Object();// 表示 t2 线程是否运行过public static boolean t2Runned = false;public static void main(String[] args) {Thread t1 = new Thread(() -> {synchronized (lock) {while (!t2Runned) {try {// 进入等待(waitSet), 会释放锁lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("1");}}, "t1");Thread t2 = new Thread(() -> {synchronized (lock) {log.debug("2");t2Runned = true;lock.notify();}}, "t2");t1.start();t2.start();}
}

使用LockSupport中的 park/unpark

可以看到，wait/notify 在实现上很麻烦：

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

/*** 使用LockSupport中的park,unpark来实现, 顺序打印 2, 1** @author xiexu* @create 2022-02-03 10:48 AM*/
@Slf4j(topic = "c.SyncPrintWaitTest")
public class SyncPrintWaitTest {public static void main(String[] args) {Thread t1 = new Thread(() -> {LockSupport.park();log.debug("1");}, "t1");Thread t2 = new Thread(() -> {log.debug("2");LockSupport.unpark(t1);}, "t2");t1.start();t2.start();}}

• park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』，不需要『同步对象』和『运行标记』
• 因为wait-notify其实是运用了保护性暂停模式，而park-unpark的底层实现其实就是保护性暂停的体现

交替输出

线程1 输出 a 5次, 线程2 输出 b 5次, 线程3 输出 c 5次。现在要求输出abcabcabcabcabcabc

wait/notify 版本

/*** Description: 使用wait/notify来实现三个线程交替打印 abcabcabcabcabc** @author xiexu* @create 2022-02-03 10:50 AM*/
@Slf4j(topic = "c.TestWaitNotify")
public class TestWaitNotify {public static void main(String[] args) {WaitNotify waitNotify = new WaitNotify(1, 5);new Thread(() -> {waitNotify.print("a", 1, 2);}, "a线程").start();new Thread(() -> {waitNotify.print("b", 2, 3);}, "b线程").start();new Thread(() -> {waitNotify.print("c", 3, 1);}, "c线程").start();}
}@Slf4j(topic = "c.WaitNotify")
@Data
class WaitNotify {// 等待标记private int flag;// 循环次数private int loopNumber;public WaitNotify(int flag, int loopNumber) {this.flag = flag;this.loopNumber = loopNumber;}/*输出内容    等待标记    下一个标记a           1          2b           2          3c           3          1*//*** @param str      打印的内容* @param waitFlag 等待标记* @param nextFlag 下一个标记*/public void print(String str, int waitFlag, int nextFlag) {for (int i = 0; i < loopNumber; i++) {synchronized (this) {while (waitFlag != this.flag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.print(str);this.flag = nextFlag;this.notifyAll();}}}}

await/signal版本

/*** 使用await/signal来实现三个线程交替打印 abcabcabcabcabc** @author xiexu* @create 2022-02-03 12:38 AM*/
@Slf4j(topic = "c.TestWaitNotify")
public class TestAwaitSignal {public static void main(String[] args) throws InterruptedException {AwaitSignal awaitSignal = new AwaitSignal(5);// a线程的休息室Condition a_condition = awaitSignal.newCondition();// b线程的休息室Condition b_condition = awaitSignal.newCondition();// c线程的休息室Condition c_condition = awaitSignal.newCondition();new Thread(() -> {awaitSignal.print("a", a_condition, b_condition);}, "a").start();new Thread(() -> {awaitSignal.print("b", b_condition, c_condition);}, "b").start();new Thread(() -> {awaitSignal.print("c", c_condition, a_condition);}, "c").start();Thread.sleep(1000);System.out.println("==========开始=========");awaitSignal.lock();try {a_condition.signal();  //首先唤醒a线程} finally {awaitSignal.unlock();}}
}class AwaitSignal extends ReentrantLock {// 循环次数private final int loopNumber;public AwaitSignal(int loopNumber) {this.loopNumber = loopNumber;}/*** @param str     打印的内容* @param current 当前线程的休息室* @param next    下一个线程的休息室*/public void print(String str, Condition current, Condition next) {for (int i = 0; i < loopNumber; i++) {lock();try {try {current.await();//System.out.print("i:==="+i);System.out.print(str);next.signal();} catch (InterruptedException e) {e.printStackTrace();}} finally {unlock();}}}
}

LockSupport的park/unpark实现

/*** 使用park/unpark来实现三个线程交替打印 abcabcabcabcabc** @author xiexu* @create 2022-02-03 12:50 AM*/
@Slf4j(topic = "c.TestWaitNotify")
public class TestParkUnpark {static Thread t1;static Thread t2;static Thread t3;public static void main(String[] args) {ParkUnpark parkUnpark = new ParkUnpark(5);t1 = new Thread(() -> {parkUnpark.print("a", t2);}, "t1");t2 = new Thread(() -> {parkUnpark.print("b", t3);}, "t2");t3 = new Thread(() -> {parkUnpark.print("c", t1);}, "t3");t1.start();t2.start();t3.start();LockSupport.unpark(t1); //首先唤醒 t1 线程}
}class ParkUnpark {// 循环次数private final int loopNumber;public ParkUnpark(int loopNumber) {this.loopNumber = loopNumber;}/*** @param str* @param nextThread 下一个要唤醒的线程*/public void print(String str, Thread nextThread) {for (int i = 0; i < loopNumber; i++) {LockSupport.park(); // 阻塞住当前线程System.out.print(str);LockSupport.unpark(nextThread); // 唤醒下一个线程}}
}

本章小结