Java 多线程共享模型之管程（下）

🚀 优质资源分享 🚀

学习路线指引（点击解锁）	知识定位	人群定位
🧡 Python实战微信订餐小程序 🧡	进阶级	本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。
💛Python量化交易实战💛	入门级	手把手带你打造一个易扩展、更安全、效率更高的量化交易系统

共享模型之管程

wait、notify

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 对象的方法。必须获得此对象的锁，才能调用这几个方法

package WaNo;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.demo2")
public class demo2 {

    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (lock){
                log.debug("执行");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码");
            }
        },"t1").start();

        new Thread(() -> {
            synchronized (lock){
                log.debug("执行");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其他代码");
            }
        },"t2").start();

        Thread.sleep(2000);
        log.debug("唤醒 lock 上其他线程");
        synchronized (lock){
            lock.notify();  //唤醒 lock 上的一个线程（随机）
            //lock.notifyAll(); //唤醒 lock 上的所有线程
        }
    }
}

• notify()

20:20:58 [t1] c.demo2 - 执行
20:20:58 [t2] c.demo2 - 执行
20:21:00 [main] c.demo2 - 唤醒 lock 上其他线程
20:21:00 [t1] c.demo2 - 其他代码

• notifyAll()

20:22:04 [t1] c.demo2 - 执行
20:22:04 [t2] c.demo2 - 执行
20:22:06 [main] c.demo2 - 唤醒 lock 上其他线程
20:22:06 [t2] c.demo2 - 其他代码
20:22:06 [t1] c.demo2 - 其他代码

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

wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是被 notify

wait、notify 正确使用

sleep vs. wait

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

step 1

思考下面的解决方案好不好，为什么？

package WaNo;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.demo4")
public class demo4 {
    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 {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]",hasCigarette);
                if(hasCigarette){
                    log.debug("开始干活！");
                }
            }
        },"小南").start();

        for(int i=0;i<5;i++){
            new Thread(() -> {
                synchronized (room){
                    log.debug("开始干活！");
                }
            },"其他人").start();
        }

        Thread.sleep(1000);
        new Thread(() -> {
            hasCigarette = true;
            log.debug("烟到了！");
        },"送烟的").start();
    }
}

输出：

20:41:09 [小南] c.demo4 - 有烟没？[false]
20:41:09 [小南] c.demo4 - 没烟，睡会！
20:41:10 [送烟的] c.demo4 - 烟到了！
20:41:11 [小南] c.demo4 - 有烟没？[true]
20:41:11 [小南] c.demo4 - 开始干活！
20:41:11 [其他人] c.demo4 - 开始干活！
20:41:11 [其他人] c.demo4 - 开始干活！
20:41:11 [其他人] c.demo4 - 开始干活！
20:41:11 [其他人] c.demo4 - 开始干活！
20:41:11 [其他人] c.demo4 - 开始干活！

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

step 2

思考下面的实现行吗，为什么？

package WaNo.step;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.demo4")
public class step2 {
    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("开始干活！");
                }
            }
        },"小南").start();

        for(int i=0;i<5;i++){
            new Thread(() -> {
                synchronized (room){
                    log.debug("开始干活！");
                }
            },"其他人").start();
        }

        Thread.sleep(1000);
        new Thread(() -> {
            synchronized (room){
                hasCigarette = true;
                log.debug("烟到了！");
                room.notify();
            }
        },"送烟的").start();
    }
}

输出：

20:46:32 [小南] c.demo4 - 有烟没？[false]
20:46:32 [小南] c.demo4 - 没烟，睡会！
20:46:32 [其他人] c.demo4 - 开始干活！
20:46:32 [其他人] c.demo4 - 开始干活！
20:46:32 [其他人] c.demo4 - 开始干活！
20:46:32 [其他人] c.demo4 - 开始干活！
20:46:32 [其他人] c.demo4 - 开始干活！
20:46:33 [送烟的] c.demo4 - 烟到了！
20:46:33 [小南] c.demo4 - 有烟没？[true]
20:46:33 [小南] c.demo4 - 开始干活！

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

step 3

package WaNo.step;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.demo4")
public class step3 {
    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) {