* JVM原理之 wait / notify正确姿态

最新推荐文章于 2023-10-09 15:27:39 发布
最新推荐文章于 2023-10-09 15:27:39 发布
阅读量192 收藏 1
点赞数
分类专栏： JVM 文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52871221/article/details/120337341
版权
本文详细介绍了Java中wait/notify机制的原理及使用，包括wait()、notify()与notifyAll()的区别，以及如何避免虚假唤醒。通过实例代码展示了在多线程协作中wait/notify的正确使用姿势，包括条件变量的控制和同步问题的解决。
摘要由CSDN通过智能技术生成

原理

wait / notify

API介绍

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

注意

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

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test18")
public class Test18 {
    static final Object lock = new Object();
    public static void main(String[] args) {

        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

notify()与notifyAll()区别

代码实例

package cn.itcast.n4;

import lombok.extern.slf4j.Slf4j;

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

@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.notify(); // 唤醒obj上一个线程
            obj.notifyAll(); // 唤醒obj上所有等待线程
        }
    }
}

运行结果

20:59:38.021 c.TestWaitNotify [t1] - 执行…
20:59:38.022 c.TestWaitNotify [t2] - 执行…
20:59:38.520 c.TestWaitNotify [main] - 唤醒 obj 上其它线程
20:59:38.520 c.TestWaitNotify [t2] - 其它代码…
20:59:38.520 c.TestWaitNotify [t1] - 其它代码…

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

API介绍

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

代码实例

package cn.itcast.test;

import cn.itcast.n2.util.Sleeper;
import lombok.extern.slf4j.Slf4j;

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

    static final Object lock = new Object();
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock) {
                log.debug("获得锁");
                try {
//                    Thread.sleep(20000);
                    lock.wait(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        Sleeper.sleep(1);
        synchronized (lock) {
            log.debug("获得锁");
        }
    }
}

运行结果

21:11:50.655 c.Test19 [t1] - 获得锁
21:11:51.654 c.Test19 [main] - 获得锁

wait notify 的正确姿势

step 1

static final Object room = new Object();
static boolean hasCigarette = false;
static boolean hasTakeout = false;
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();

运行结果

20:49:49.883 [小南] c.TestCorrectPosture - 有烟没？[false]
20:49:49.887 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:49:50.882 [送烟的] c.TestCorrectPosture - 烟到了噢！
20:49:51.887 [小南] c.TestCorrectPosture - 有烟没？[true]
20:49:51.887 [小南] c.TestCorrectPosture - 可以开始干活了
20:49:51.887 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.887 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了

总结

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

step 2

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();
北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
输出
20:51:42.489 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:51:42.493 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:51:42.493 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.493 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:43.490 [送烟的] c.TestCorrectPosture - 烟到了噢！
20:51:43.490 [小南] c.TestCorrectPosture - 有烟没？[true] 
20:51:43.490 [小南] c.TestCorrectPosture - 可以开始干活了
解决了其它干活的线程阻塞的问题
但如果有其它线程也在等待条件呢？
step 3
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();

运行结果

20:51:42.489 [小南] c.TestCorrectPosture - 有烟没？[false]
20:51:42.493 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:51:42.493 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.493 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:42.494 [其它人] c.TestCorrectPosture - 可以开始干活了
20:51:43.490 [送烟的] c.TestCorrectPosture - 烟到了噢！
20:51:43.490 [小南] c.TestCorrectPosture - 有烟没？[true]
20:51:43.490 [小南] c.TestCorrectPosture - 可以开始干活了

总结

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

step 3

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 {
北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090
输出
20:53:12.173 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:53:12.176 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:53:12.176 [小女] c.TestCorrectPosture - 外卖送到没？[false] 
20:53:12.176 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:53:13.174 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:53:13.174 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:53:13.174 [小南] c.TestCorrectPosture - 没干成活... 
notify 只能随机唤醒一个 WaitSet 中的线程，这时如果有其它线程也在等待，那么就可能唤醒不了正确的线
程，称之为【虚假唤醒】
解决方法，改为 notifyAll
step 4
 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();

运行结果

20:53:12.173 [小南] c.TestCorrectPosture - 有烟没？[false]
20:53:12.176 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:53:12.176 [小女] c.TestCorrectPosture - 外卖送到没？[false]
20:53:12.176 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:53:13.174 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:53:13.174 [小南] c.TestCorrectPosture - 有烟没？[false]
20:53:13.174 [小南] c.TestCorrectPosture - 没干成活…

总结

notify 只能随机唤醒一个 WaitSet 中的线程，这时如果有其它线程也在等待，那么就可能唤醒不了正确的线
程，称之为【虚假唤醒】
解决方法，改为 notifyAll

step 4

new Thread(() -> {
 synchronized (room) {
 hasTakeout = true;
 log.debug("外卖到了噢！");
 room.notifyAll();
 }
}, "送外卖的").start();

运行结果

20:55:23.978 [小南] c.TestCorrectPosture - 有烟没？[false]
20:55:23.982 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:55:23.982 [小女] c.TestCorrectPosture - 外卖送到没？[false]
20:55:23.982 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:55:24.979 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:55:24.979 [小女] c.TestCorrectPosture - 外卖送到没？[true]
20:55:24.980 [小女] c.TestCorrectPosture - 可以开始干活了
20:55:24.980 [小南] c.TestCorrectPosture - 有烟没？[false]
20:55:24.980 [小南] c.TestCorrectPosture - 没干成活…

总结

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

step 5

if (!hasCigarette) {
 log.debug("没烟，先歇会！");
 try {
 room.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
}
while (!hasCigarette) {
 log.debug("没烟，先歇会！");
 try {
 room.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
}

运行结果

20:58:34.322 [小南] c.TestCorrectPosture - 有烟没？[false]
20:58:34.326 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:58:34.326 [小女] c.TestCorrectPosture - 外卖送到没？[false]
20:58:34.326 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:58:35.323 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:58:35.324 [小女] c.TestCorrectPosture - 外卖送到没？[true]
20:58:35.324 [小女] c.TestCorrectPosture - 可以开始干活了
20:58:35.324 [小南] c.TestCorrectPosture - 没烟，先歇会！

总结

synchronized(lock) {
 while(条件不成立) {
 lock.wait();
 }
 // 干活
}
//另一个线程
synchronized(lock) {
 lock.notifyAll();
}
深蓝霍克
关注
专栏目录
共享模型之管程(四)
xp_xpxp的博客
01-05 281
wait/notify相关知识
synchronized的底层原理
学习
02-19 505
synchronized使用方式 我们知道并发编程会产生各种问题的源头是可见性，原子性，有序性。 而synchronized能同时保证可见性，原子性，有序性。所以我们在解决并发问题的时候经常用synchronized，当然还有很多其他工具，如volatile。但是volatile只能保证可见性，有序性，不能保证原子性。参见之前的文章volatile关键字——保证并发编程中的可见性、有序性 sync...
Java的wait和notify学习三部曲之一：JVM源码分析
程序员欣宸的博客
07-29 605
综述Java的wait()、notify()学习三部曲由三篇文章组成，内容分别是：一、通过阅读openjdk8的源码，分析和理解wait，notify在JVM中的具体执行...
使用 wait / notify 的正确姿势
weixin_58104242的博客
03-09 180
public class ToTest { static final Object room = new Object(); static boolean hasCigarette = false; static boolean hasTakeout = false; public static void main(String[] args) throws InterruptedException { new Thread(() -> { .
JVM源码分析之wait()和notify()
lzf的博客
12-29 1754
wait() 在linux 下 调用 pthread_cond_wait()阻塞在条件变量上 notify()方法在linux下调用pthread_cond_signal()唤醒阻塞在条件变量上的线程
JVM源码分析之Object.wait/notify(All)完全解读
weixin_33704234的博客
04-10 189
概述 本文其实一直都想写，因为各种原因一直拖着没写，直到开公众号的第一天，有朋友再次问到这个问题，这次让我静心下来准备写下这篇文章，本文有些东西是我自己的理解，比如为什么JDK一开始要这么设计，初衷是什么，没怎么去找相关资料，所以只能谈谈自己的理解，所以大家看到文章之后可以谈谈自己的看法，对于实现部分我倒觉得说清楚问题不大，code is here，...
wait notify的正确使用
weixin_44715154的博客
04-18 248
wait notify的正确使用 先看看 sleep（long n）和 wait（long n）的区别： sleep是Thread方法，而wait是Object的方法 slee不需要强制和synchronized配合使用，但wait需要和synchronized一起使用（需要拿到对象使用权才能进入对象的waitset中） sleep在睡眠的同时，不会释放对象锁，但wait在等待的时候会释放对象锁 它们的状态都是TIMED-WAITING wait notify的正确使用姿势： // 多个等待线程 syn
共享模型之管程
weixin_50458070的博客
10-09 95
黑马juc
【Java并发编程最佳实践】：掌握Concurrent包的正确使用姿势（权威指南）
[【Java并发编程最佳实践】：掌握Concurrent包的正确使用姿势（权威指南）](https://img-blog.csdnimg.cn/a0ea50d34dc746439fb51afd8a3908ca.png) # 1. Java并发编程概述 并发编程是现代编程语言和系统设计的一个...
关于同步的一些原理
angelina716的博客
09-24 890
关于线程并发的一些底层原理记录 进程：进程是是程序的一次执行过程，是程序在执行过程中分配和管理资源的基本单位。 线程：是CPU调度的最小单位。它比进程更小，一个进程可以包含多个线程，线程会共享进程的堆和方法区资源。每个线程也有自己的程序计数器，虚拟机栈和本地方法栈。 一个java程序的运行是main线程和其他线程同时运行。 因为多线程运行： 原因：单核时代：多线程主要提高单进程利用CPU和IO的效率。一个线程被IO阻塞，其他线程可以继续使用CPU。 多核时代：多线程主要为了提升利用多核CPU的能力。
Java多线程 - 如何正确的使用wait-notify方法？
你今天真好看呀
03-01 279
文章目录1. sleep(long n) 和 wait(long n) 的区别2. 正确使用wait-notify方法 [while(条件)+wait]2.1 问题12.2 问题22.3 问题32.4 问题42.5 最终结果 问题： sleep() 和 wait() 有什么区别？ 1. sleep(long n) 和 wait(long n) 的区别 (1) sleep 是 Thread 方法，而 wait 是 Object 的方法 ; (2) sleep 不需要强制和 synchronized 配合使用
Java的wait()、notify()：JVM源码分析
z69183787的专栏
03-10 772
源码调试方法：https://blog.csdn.net/boling_cavalry/article/details/70557537 转自：https://blog.csdn.net/boling_cavalry/article/details/77793224 ###wait()和notify()的通常用法### Java多线程开发中，我们常用到wait()和notify()方...
1.深入JVM源码，查看如何实现wait()，notify()方法
义笔记
06-08 7328
1.深入JVM源码，查看如何实现wait() 在java中，每个对象都是Object的子类，java中每个对象都是"锁"，但是这是如何实现的呢，今天我们看看JVM层面如何实现Object.wait/notify方法的。 在讲这个之前我们需要了解一下java的对象在内存中的布局情况； 1.对象头：下面重点讲解 2.实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐 3.填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的
jvm的线程之间的通信-notify-wait-notifyAll
一阴一阳之谓道
05-15 538
超类 Object 类 使用 native code 实现的 线程之间的 通信是怎样的？
java线程切换 notify_浅谈 Java线程状态转换及控制
weixin_28908491的博客
02-17 204
作者：城北有个混子出自：博客园1、线程的状态(系统层面)一个线程被创建后就进入了线程的生命周期。在线程的生命周期中，共包括新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)这五种状态。当线程启动以后，CPU需要在多个线程之间切换，所以线程也会随之在运行、阻塞、就绪这几种状态之间切换。线程的状态转换如图：当使用new关键字创建一个线程对象后，该...
Java多线程——wait、notify、notifyAll用法
世上本没有路，走的人多了，也便成了路
11-07 232
本文介绍了wait、notify和notifyAll的特性以及用法，还有相关注意事项等。
彻底搞懂Java的等待-通知(wait-notify)机制
热门推荐
全菜工程师小辉的博客
08-06 1万+
线程的生命周期转换 新建状态（New）：新建一个线程对象。 就绪/可运行状态（Runnable）：线程对象创建后，其他线程调用了该对象的start方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 运行状态（Running）：就绪状态的线程获得CPU并执行程序代码。 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用...
并发编程（共享模型之管程wait notify）
kopoo的博客
11-17 330
本文主要讲解wait/notify的正确使用姿势、park/unpark、join()的原理、模式之生产者-消费者模式(异步)、保护性暂停模式(同步)、线程状态转换的流程、死锁和活锁以及如何检查死锁等。 一、 wait notify API 介绍 obj.wait() 让进入 object 监视器的线程到 waitSet 等待 obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒 obj.notifyAll() 让 object 上正在 waitSet.
从源码角度分析java 的 sleep()和wait()究竟有什么区别？
jackhu专栏
04-10 3230
要知道根本区别，最好的还是看源代码 1. sleep() 的根本实现 jvm sleep()---->jni sleep()-------->  最终会进入系统的sys_pasue()调用，而sys_pause() 则会调用 schedule(), schedule() 则会主动放弃cpu 时间片，进入等待队列 asmlinkage int sys_pause(void) {
-javaagent:/home/*******/.local/share/jetbra/ja-netfilter.jar
最新发布
08-07
路径`/home/*******/.local/share/jetbra/ja-netfilter.jar`指向的是你要使用的Java代理jar文件，它可能包含了一个实现了特定接口（如`com.sun.instrument.Instrumentation`）的类，该类会在JVM启动时自动加载并执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值