JUC共享模型之管程阶段四

最新推荐文章于 2023-10-16 15:39:28 发布
最新推荐文章于 2023-10-16 15:39:28 发布
阅读量283 收藏
点赞数
文章标签： juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36437693/article/details/120245292
版权
本文深入探讨了Java并发编程中的管程概念，包括wait、notify和notifyAll方法的使用及原理。通过实例分析了线程间的协作，如保护性暂停模式和生产者/消费者模式。同时讲解了park与unpack方法的基本使用和原理，以及线程状态转换。此外，介绍了ReentrantLock的特性，如可重入、可打断、超时等待和公平锁，并通过示例展示了如何利用条件变量解决并发问题。最后，文章总结了线程安全、死锁、活锁和饥饿问题，帮助读者理解线程的活跃性挑战。
摘要由CSDN通过智能技术生成

4.6 wait和notify

建议先看看wait和notify方法的javadoc文档

API 介绍

obj.wait() 让进入 object 监视器的线程到 waitSet 等待

obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒 ，随机唤醒一个线程

obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

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

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("其它代码....");
 }
 }).start();
 new Thread(() -> {
 synchronized (obj) {
 log.debug("执行....");
 try {
 obj.wait(); // 让线程在obj上一直等待下去
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 log.debug("其它代码....");
 }
 }).start();
 // 主线程两秒后执行
 sleep(2);
 log.debug("唤醒 obj 上其它线程");
 synchronized (obj) {
 obj.notify(); // 唤醒obj上一个线程
 // obj.notifyAll(); // 唤醒obj上所有等待线程
 }
}

 notify 的一种结果

20:00:53.096 [Thread-0] c.TestWaitNotify - 执行.... 
20:00:53.099 [Thread-1] c.TestWaitNotify - 执行.... 
20:00:55.096 [main] c.TestWaitNotify - 唤醒 obj 上其它线程
20:00:55.096 [Thread-0] c.TestWaitNotify - 其它代码....

 notifyAll 的结果

19:58:15.457 [Thread-0] c.TestWaitNotify - 执行.... 
19:58:15.460 [Thread-1] c.TestWaitNotify - 执行.... 
19:58:17.456 [main] c.TestWaitNotify - 唤醒 obj 上其它线程
19:58:17.456 [Thread-1] c.TestWaitNotify - 其它代码.... 
19:58:17.456 [Thread-0] c.TestWaitNotify - 其它代码....

wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就有机会获取对象的锁。无限制等待，直到 notify 为止， wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是被 notify

wait和notify原理

友情提示：waiting表示的是已经获得锁但是放弃锁（对应的就是wait），Blocked是希望能获取锁(对应sleep)

 wait和notify正确使用姿势

友情提示：这里多次提到虚假唤醒，当唤醒多个线程中，有部分是无用功，这些无用功的唤醒的就是虚假唤醒。

代码1:

package cn.itcast.n4;

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestCorrectPosture")
public class TestCorrectPostureStep1 {
    static final Object room = new Object();
    static boolean hasCigarette = false; // 有没有烟
    static boolean hasTakeout = false;

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    sleep(2);
                }
                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("烟到了噢！");
//            }
        }, "送烟的").start();
    }

}

输出结果

代码2：

友情提示：相比上面的代码，这里在送烟的方法中加入了synchronized这是有问题的，这会导致送烟的时候获取不到锁，必须要先让小南sleep两秒才能释放锁，这样小南就没有干活。

@Slf4j(topic = "c.TestCorrectPosture")
public class TestCorrectPostureStep1 {
    static final Object room = new Object();
    static boolean hasCigarette = false; // 有没有烟
    static boolean hasTakeout = false;

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    sleep(2);
                }
                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("烟到了噢！");
            }
        }, "送烟的").start();
    }

}

结果：

发现小南没有干活

 说明问题：使用sleep解决向下运行的缺点,后面的其他人都必须等待小南完成之后才能干活导致效率低下。

 针对上面的问题使用wait和notify

代码

package cn.itcast.n4;

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestCorrectPosture")
public class TestCorrectPostureStep2 {
    static final Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        room.wait(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();
        }

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

}

运行结果

 使用notifyAll唤醒所有阻塞的线程

package cn.itcast.n4;

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestCorrectPosture")
public class TestCorrectPostureStep3 {
    static final Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;

    // 虚假唤醒
    public static void main(String[] args) {
        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();


    }

}

 结果

注意，这里只是唤醒了小女，但是虚假唤醒了小南。

 解决上面问题

将if改成while

package cn.itcast.n4;

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestCorrectPosture")
public class TestCorrectPostureStep4 {
    static final Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;

    public static void main(String[] args) {


        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
最低0.47元/天 解锁文章
「已注销」
关注
专栏目录
JUC共享模型之无锁并发阶段六
亚索@哈塞给
09-20 228
6. 共享模型之无锁 管程即monitor是阻塞式的悲观锁实现并发控制，这章我们将通过非阻塞式的乐观锁的来实现并发控制。 友情提示：无锁并发就是不需要锁控制并发 6.1 问题提出 有如下需求，保证account.withdraw取款方法的线程安全 public class Test5 { public static void main(String[] args) { Account.demo(new AccountUnsafe(10000)); } } cl
JUC-管程
微信公众号：饺子泡牛奶
08-22 1070
章节目录： 一、什么是管程 1.1 概述 1.2 管程组成部分 1.3 变量共享问题 1.4 临界区概述 1.5 解决方案 二、synchronized 2.1 概述 2.2 使用 synchronized 解决变量共享问题 2.3 其它加锁情况
JUC (三) --------- 管程 (Monitor)
在森林里麋了鹿
10-14 921
JUC 管程详解
2.JUC-共享模型之管程
孤独的木头人的博客
04-30 638
共享模型之管程 1. 共享带来的问题 小故事 老王（操作系统）有一个功能强大的算盘（CPU），现在想把它租出去，赚一点外快 小南、小女（线程）来使用这个算盘来进行一些计算，并按照时间给老王支付费用 但小南不能一天24小时使用算盘，他经常要小憩一会（sleep），又或是去吃饭上厕所（阻塞 io 操作），有时还需要一根烟，没烟时思路全无（wait）这些情况统称为（阻塞） 在这些时候，算盘没利用起...
JUC-进程、线程和管程
江黎
09-22 278
进程是资源分配的基本单位，每个进程都独享一块内存空间。 线程指进程中的一个执行流程，一个进程可以包含多个线程。 每个进程都需要操作系统为其分配独立的内存空间，而同一个进程中的多个线程共享这块空间，即共享内存等资源。 管程：Monitor（监视器），也就是我们平时所说的锁。Monitor其实是一种同步机制，它能保证同一时间只有一个线程可以访问被保护的数据和代码。Jvm中同步是基于进入和退出监视器对象（Monitor管程对象）来实现的，每个对象实例都会有一个Monitor对象。Monitor对象会和Jav
【刨根问底】带你深入理解JUC并发工具类 — 信号量和管程
Java不惑
08-28 262
大家好，我是Java不惑（WX公众号同名），这是专栏的第三篇文章。 在前面的两篇文章中，我介绍了volatile、cas以及其在处理器中的实现。 我们需要知道，volatile和cas是最基础的工具，实际的业务场景中共享变量的同步问题是非常复杂的，所以很少直接使用它们来处理同步问题。 基于这个工具上面我们可以封装成“锁”，方便我们解决多线程同步问题。今天我会讲一下基于volatile+cas实现的同步机制，也就是信号量和管程。 信号量 信号量的概念是由荷兰计算机科学家艾兹赫尔·戴克斯特拉（Edsger W
共享模型之管程
weixin_50458070的博客
10-09 80
黑马juc
共享模型之无锁
weixin_50458070的博客
10-16 109
黑马juc
JUC详细笔记
leedoc的博客
11-05 879
此笔记根据黑马JUC课程整理 1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其
JUC学习系列四（条件锁 condition）
qq_38872310的博客
07-24 758
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 Condition 实例实质上被绑定到一个锁上...
Javaweb学习笔记（JDBC入门）
qq_50834939的博客
02-08 1564
Javaweb学习笔记（JDBC入门）JDBC概述JDBC常用API JDBC概述 JDBC全称是Java数据库连接，是一套用于执行SQL语句的Java API,应用程序可以通过JDBC连接到关系数据库，并使用SQL语句来完成对数据库中数据的查询、更新和删除操作。 JDBC实现包括三部分： （1）JDBC驱动管理器：负责注册特定的JDBC驱动器，主要通过java.sql.DriverManager类实现。 （2）JDBC驱动器API：最主要的接口是java.sqlDriver接口 （3）JDBC驱动器：一种
17_juc
海涛帅帅的博客
09-14 453
Java JUC简介 在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。 volatile关键字-内存可见性 概述 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个
【＜多线程常用方法＞】
徐明晓的博客
08-05 375
多线程常用方法[1] start 与 run[2] sleep 与 yield[3] sleep 和 wait[4] Daemon[5] join和yield[6] wait() notify() notifyAll()[7] await() signal() signalAll()[8] InterruptedException[9] interrupted()[10] Executor[11] CopyOnWriteArrayList [1] start 与 run https://www.cnblo
JUC并发编程——多把锁
m0_56188609的博客
03-07 611
线程1按AB的顺序加锁，先获得锁A，线程2也是按AB的顺序进行加锁，线程2此时想获取对象A的锁时获取失败（进入对象A的EntryList中阻塞），这时线程1再尝试获取B对象的锁。死锁是两个线程持有对方需要的锁，导致线程都无法继续向下运行，两个线程均陷入阻塞；● 使两个线程的执行时间有一定的交错（不集中在一起执行/设置睡眠的时间为一个随机数===>将其指令交错开，第一个线程很快运行完，第二个线程将没有机会改变对方的结束条件）现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低。
java并发编程 笔记十一
笨鸟先飞
03-19 199
同步模式之顺序控制 1. 固定运行顺序 比如，必须先 2 后 1 打印 1.1 wait notify 版 // 用来同步的对象 static Object obj = new Object(); // t2 运行标记， 代表 t2 是否执行过 static boolean t2runed = false; public static void main(...
Java线程(创建线程、线程的状态，常见使用方法，如何优雅的停止线程)
zjj_flower的博客
06-12 781
如何常见一个线程、线程的常见的方法、如何优雅的结束一个线程
Java线程池简介 参数设置原则
trigger的博客
02-25 1821
资料来源 javaguide 4 java线程池是什么 有什么用 重要参数 饱和策略 执行流程 如何使用 见代码 package cn.itcast.n8; import cn.itcast.n2.util.Sleeper; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicIntege...
基于Java语言的蓝牙遥控器设计源码，支持键盘、鼠标、影音遥控器
最新发布
10-05
该项目为基于Java语言的蓝牙遥控器设计源码，包含539个文件，涵盖307个Java源文件、120个XML配置文件、34个PNG图片文件、16个Gradle构建文件、12个Git忽略文件、9个文本文件、6个JAR包文件、5个JSON配置文件、5个JPG图片文件。该遥控器支持键盘、鼠标和影音控制功能，适用于多种场合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

「已注销」

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值