（五）共享模型之管程【wait notify 】

news2024/9/29 13:30:03

一、wait notify 

1. 小故事 - 为什么需要 wait

2. 原理之 wait / notify

（1）Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态。 

（2）BLOCKED 和WAITING 的线程都处于阻塞状态，不占用 CPU 时间片。

（3）BLOCKED 线程会在 Owner 线程释放锁时唤醒。

（4）WAITING 线程 会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味着立刻获得锁，仍需要进入 EntryList 重新竞争。

3. API 介绍

（1）obj.wait()：让进入 Object 监视器的线程到 waitSet 等待

（2）obj.notify()：在 Object 上正在 waitSet 等待的线程中挑一个唤醒

（3）obj.notifyAll()：让 Object 上正在 waitSet 等待的线程中全部唤醒

它们都是线程之间进行协作的手段，都属于 Object 对象的方法。 必须获得此对象的锁 ，才能调用这几个方法
wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到  notify 为止
wait(long n) 有时限的等待 , 到 n 毫秒后结束等待，或是被 notify

二、wait notify 的正确姿势

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

（1）sleep 是 Thread 方法，而 wait 是 Object 的方法

（2）sleep不需要强制和 synchronized 配合使用，但 wait 需要

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

（4）它们状态 TIMED_WAITING

2. 正确姿势

3. 同步模式之保护性暂停

3.1 定义

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

要点：

（1）有一个结果需要从一个线程传递到了另一个线程，让它们关联同一个 GuardedObject。

（2）如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）。

（3）JDK 中，join 的实现、Future 的实现，采用的就是此模式。

（4）因为要等待另一方的结果，因此归类到同步模式。

3.2 实现

@Slf4j(topic = "c.Test20")
public class Test20 {
    public static void main(String[] args) throws InterruptedException {
        GuardedObject guardedObject = new GuardedObject();
        new Thread(()->{
            log.debug("等待结果");
            ArrayList<Integer> list = (ArrayList<Integer>) guardedObject.get();
            log.debug("结果大小:{}",list.size());
        },"t1").start();

        new Thread(()->{
            log.debug("执行下载");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(1);
            list.add(1);
            guardedObject.complete(list);
        },"t2").start();
    }
}

class GuardedObject {

    // 结果
    private Object response;

    // 获取结果
    public Object get() {
        synchronized (this) {
            while (response == null){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

3.3 带超时版 GuardedObject

@Slf4j(topic = "c.Test20")
public class Test20 {
    public static void main(String[] args) throws InterruptedException {
        GuardedObject guardedObject = new GuardedObject();
        new Thread(()->{
            log.debug("等待结果");
            ArrayList<Integer> list = (ArrayList<Integer>) guardedObject.get(2000);
            log.debug("结果是:{}",list);
        },"t1").start();

        new Thread(()->{
            log.debug("执行下载");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(1);
            list.add(1);
            guardedObject.complete(list);
        },"t2").start();
    }
}

// 增加超时效果
class GuardedObject {

    // 结果
    private Object response;

    // 获取结果
    // timeout 表示要等待多久 2000
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间时，退出循环
                if (timeout - passedTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime); // 虚假唤醒 15:00:01
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02  1s
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

3.4 原理之 join

是调用者轮询检查线程 alive 状态 
t1.join();

等价于

synchronized (t1) {
 // 调用者线程进入 t1 的 waitSet 等待, 直到 t1 运行结束
 while (t1.isAlive()) {
 t1.wait(0);
 }
}
join 体现的是【保护性暂停】模式

3.5 多任务版 GuardedObject

图中 Futures 就好比居民楼一层的信箱（每个信箱有房间编号），左侧的 t0 ， t2 ， t4 就好比等待邮件的居民，右侧的 t1 ， t3 ， t5 就好比邮递员
如果需要在多个类之间使用 GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类， 这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理

 

（1）新增 id 用来标识 Guarded Object

// 增加超时效果
class GuardedObject {

    // 标识 Guarded Object
    private int id;

    public GuardedObject(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    // 结果
    private Object response;

    // 获取结果
    // timeout 表示要等待多久 2000
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间时，退出循环
                if (timeout - passedTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime); // 虚假唤醒 15:00:01
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02  1s
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}
（2）中间解耦类 
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();
    }
}
（3）业务相关类 
@Slf4j(topic = "c.People")
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);
    }
}

@Slf4j(topic = "c.Postman")
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);
    }
}

（4）测试

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

4. 异步模式之生产者消费者

4.1 定义

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

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

（3）生产者仅负责产生结果数据，不关系数据该如何处理，而消费者专心处理结果数据。

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

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

 

4.2 实现

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

    public static void main(String[] args) {
        MessageQueue queue = new MessageQueue(2);

        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                queue.put(new Message(id , "值"+id));
            }, "生产者" + i).start();
        }

        new Thread(() -> {
            while(true) {
                sleep(1);
                Message message = queue.take();
            }
        }, "消费者").start();
    }

}

// 消息队列类 ， java 线程之间通信
@Slf4j(topic = "c.MessageQueue")
class MessageQueue {
    // 消息的队列集合
    private LinkedList<Message> list = new LinkedList<>();
    // 队列容量
    private int capcity;

    public MessageQueue(int capcity) {
        this.capcity = capcity;
    }

    // 获取消息
    public Message take() {
        // 检查队列是否为空
        synchronized (list) {
            while(list.isEmpty()) {
                try {
                    log.debug("队列为空, 消费者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从队列头部获取消息并返回
            Message message = list.removeFirst();
            log.debug("已消费消息 {}", message);
            list.notifyAll();
            return message;
        }
    }

    // 存入消息
    public void put(Message message) {
        synchronized (list) {
            // 检查对象是否已满
            while(list.size() == capcity) {
                try {
                    log.debug("队列已满, 生产者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 将消息加入队列尾部
            list.addLast(message);
            log.debug("已生产消息 {}", message);
            list.notifyAll();
        }
    }
}

final class Message {
    private int id;
    private Object value;

    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }

    public int getId() {
        return id;
    }

    public Object getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", value=" + value +
                '}';
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/55418.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[附源码]计算机毕业设计springboot线上社区管理系统

[附源码]计算机毕业设计springboot线上社区管理系统

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
全力护航！广西移动圆满完成区运会通信保障任务

全力护航！广西移动圆满完成区运会通信保障任务

11月23日晚&#xff0c;广西壮族自治区第十五届运动会在贵港市体育中心闭幕。作为区域主导通信运营商&#xff0c;广西移动贵港分公司充分发挥5G网络技术优势&#xff0c;与贵港市政府、区运会组委会紧密合作&#xff0c;全力以赴为运动会提供了先进、高效的通信服务保障。 广西…
阅读更多...
PAT (甲级) 2022年秋季考试 c++ 满分题解

PAT (甲级) 2022年秋季考试 c++ 满分题解

PAT (甲级) 2022年秋季考试 c 满分题解 7-1 Balloon Popping 分数 20 原题 算法标签 模拟 枚举 思路 枚举数组元素&#xff0c; 判断每个元素覆盖气球数, 记录最多可覆盖气球数及最多可覆盖气球数开始下标&#xff0c; 则最小开始值为最后可覆盖气球位置减高度H 代码 #…
阅读更多...
matlab如何滤除低频尖峰脉冲

matlab如何滤除低频尖峰脉冲

有时&#xff0c;数据会出现不必要的瞬态或尖峰。可以用中值过滤消除它们。 最近我们被客户要求撰写关于信号滤除脉冲数据的研究报告&#xff0c;包括一些图形和统计输出。 在存在60 Hz电源线噪声的情况下&#xff0c;考虑模拟仪器输入端的开环电压。采样率为1 kHz。 fs …
阅读更多...
基于Python pygame简易版斗兽棋小游戏源代码

基于Python pygame简易版斗兽棋小游戏源代码

基于Python pygame简易版斗兽棋小游戏源代码 游戏规则如下: 胜利条件: 1.吃掉对方全部棋子 2.走入对方兽穴(不可进入自己洞穴) 吃法: 1.象>狮>虎>豹>狼>狗>猫>鼠>象 2.同类棋子先行者吃掉对方 3.老鼠可以进河,老鼠在河里时,岸上的动物不能捕食他…
阅读更多...
Jmeter常用函数用法详解

Jmeter常用函数用法详解

Jmeter函数官网帮助手册&#xff1a;https://jmeter.apache.org/usermanual/functions.html#__BeanShell 1.__intSum:计算两个或多个整数值的和 参数是否必传第一个int值是第二个int值是第n个int值否变量名否 eg: ${__intSum(1,2)} //return 123 ${__intSum(1,2,3)} //return …
阅读更多...
（8）点云数据处理学习——ICP registration（迭代最近点）

（8）点云数据处理学习——ICP registration（迭代最近点）

1、主要参考 &#xff08;1&#xff09;官方介绍地址 ICP registration — Open3D 0.16.0 documentation 2、介绍 2.1 原理 &#xff08;1&#xff09;关于ICP registration 本教程演示ICP(迭代最近点)配准算法。多年来&#xff0c;它一直是研究和工业中几何配准的支柱。输…
阅读更多...
股票接口怎么解析股票历史数据？

股票接口怎么解析股票历史数据？

最近有很多投资者在研究股票接口怎么解析股票历史数据&#xff0c;然后执行自动交易等方面对开发股票数据接口的深入思考。其实在小编看来&#xff0c;这就需要先获取股票的每日数据&#xff0c;那么就会使用Python来解析股票历史数据&#xff0c;下面小编就简要介绍使用Python…
阅读更多...
Java8-Stream流详细教程

Java8-Stream流详细教程

前言 1、什么是Stream 前面我们讲了Lambda表达式与Optional类&#xff0c;下面我们将会使用这两个新特性&#xff0c;特别是Lambda。 Stream 是数据渠道&#xff0c;用于操作数据源(集合、数组等)所生成的元素序列 集合讲的是数据&#xff0c;Stream讲的是计算&#xff01; 注…
阅读更多...
Java 守护线程

Java 守护线程

✨✨hello&#xff0c;愿意点进来的小伙伴们&#xff0c;你们好呐&#xff01; &#x1f43b;&#x1f43b;系列专栏&#xff1a;【JavaEE初阶】 &#x1f432;&#x1f432;本篇内容&#xff1a;详解守护线程 &#x1f42f;&#x1f42f;作者简介:一名现大二的三非编程小白&am…
阅读更多...
什么是云计算？什么是边缘计算？为什么需要云边协同？

什么是云计算？什么是边缘计算？为什么需要云边协同？

一、云计算的发展有哪些弊端&#xff1f; **云计算&#xff08;cloud computing&#xff09;**是分布式计算的一种&#xff0c;指的是通过网络“云”将巨大的数据计算处理程序分解成无数个小程序&#xff0c;然后&#xff0c;通过多部服务器组成的系统进行处理和分析这些小程序…
阅读更多...
Android 启动流程梳理

Android 启动流程梳理

前言 什么是Android启动流程呢&#xff1f;其实指的就是我们Android系统从按下电源到显示界面的整个过程。 当我们把手机充好电&#xff0c;按下电源&#xff0c;手机会弹出相应启动界面&#xff0c;在等了一段时间之后&#xff0c;会弹出我们熟悉的主界面&#xff0c;这其实就…
阅读更多...
开源数据备份工具 Duplicati

开源数据备份工具 Duplicati

使用 Duplicati 腾讯云 COS&#xff0c;完美备份我的服务器数据。 文件备份需求 我有两台腾讯云的服务器&#xff0c;一台部署了博客&#xff0c;一台部署了一些个人项目&#xff0c;虽说云服务器很稳定&#xff0c;基本不会发生丢失数据的问题&#xff0c;但我个人之前经历过…
阅读更多...
ThreeJs学习

ThreeJs学习

1 基本使用 //1、创建场景 const scene new THREE.Scene() //2、创建网格模型 const geometry new THREE.BoxGeometry(100,100,100) const matrial new THREE.MeshLambertMaterial({color: #0000ff }) const mesh new THREE.Mesh(geometry,matrial) scene.add(mesh) //3、…
阅读更多...
Redis之String类型和Hash类型的介绍和案例应用

Redis之String类型和Hash类型的介绍和案例应用

一. String类型基础 1.类型介绍 典型的Key-Value集合&#xff0c;如果要存实体&#xff0c;需要序列化成字符串&#xff0c;获取的时候需要反序列化一下。 2. 指令Api说明 ​ 编辑3.常用Api说明 (1).StringSet&#xff1a;写入数据,如果数据已经存在,则覆盖;可以一次性存入1…
阅读更多...
B2B电子商务策略[在2022年发展您的业务]

B2B电子商务策略[在2022年发展您的业务]

常规的电子商务商店向消费者&#xff08;B2C 或企业对消费者&#xff09;销售产品。B2B&#xff08;企业对企业&#xff09;电子商务不同于常规电子商务&#xff0c;因为 B2B电子商务的商业模式是让一家企业在线向另一家公司销售产品。 您可能会想&#xff1a;如何向企业销售比…
阅读更多...
Windows OpenGL 图像色调

Windows OpenGL 图像色调

目录 一.OpenGL 图像色调调节 1.原始图片2.效果演示 二.OpenGL 图像色调调节源码下载三.猜你喜欢 零基础 OpenGL ES 学习路线推荐 : OpenGL ES 学习目录 >> OpenGL ES 基础 零基础 OpenGL ES 学习路线推荐 : OpenGL ES 学习目录 >> OpenGL ES 特效 零基础 OpenGL…
阅读更多...
Ubuntu 20.04 server永久关闭swap

Ubuntu 20.04 server永久关闭swap

方法一 编辑/etc/fstab &#xff0c;sudo vim /etc/fstab&#xff0c;找到如下行 找到/dev/disk/by-uuid/28b306c5-92e4-4180-966d-cdedfbce3a4d /boot ext4 defaults 0 1 修改为如下图&#xff0c;并(/swap.img none swap sw 0 0) 将如下行注释&#…
阅读更多...
Yolo算法检测之Anchor Boxes原理详解

Yolo算法检测之Anchor Boxes原理详解

刚开始yolo系列的目标检测算法&#xff0c;在一个网格中只能检测一个对象&#xff0c;但是我们在实验中发现&#xff0c;一个网格中很多时候存在不仅一个目标&#xff0c;可能存在多个目标&#xff0c;类似如下图所示&#xff0c;下面中间的网格中就存在人和车辆两个目标的中心…
阅读更多...
嵌入式开发学习之--Git管理代码

嵌入式开发学习之--Git管理代码

本章主要介绍一下代码管理&#xff0c;在最后有常用的git指令&#xff0c;可以档资料收藏一下。 文章目录前言一、Github是什么二、Github的简单应用1.新建库 git init2. 添加文件 git add .2. 提交到本地仓库 git commit -m "注释"3. 创建分支 Git checkout -b [分支…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023