Java多线程wait/notify原理

最新推荐文章于 2023-11-04 13:41:58 发布
最新推荐文章于 2023-11-04 13:41:58 发布
阅读量969 收藏 2
点赞数 2
分类专栏： Java多线程 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jayu_37/article/details/113435102
版权

1. 引入wait/notify

回顾：在之前的学习中，当我们创建一个对象后，synchronized给对象上锁，JVM会给对象头关联一个Monitor对象，这个Monitor由三部分组成。
一是Owner对象，里面存储的是创建该对象的线程
二是EntryList，想试图获取该对象资源的其它堵塞线程队列
三是WaitSet，存储的是放弃对象锁的线程
在这里插入图片描述

  • Owner线程中的锁对象，如果发现条件不满足，调用wait()方法，既可以进入到WaitSet变为WAITING状态
  • EntryList下和WaitSet下的线程都属于堵塞状态，不占用CPU时间片
  • EntryList下的线程会在Owner是释放锁时被唤醒
  • WaitSet下的线程会在Owner线程调用notify或notifyAll时被唤醒，但是唤醒后并不意味立刻获得锁，需要进入EntryList重新竞争锁

2. API介绍

obj.wait() 会让obj对象由拥有锁到暂时放弃锁，进入到waitset中
obj.notify() 会唤醒在waitset中的线程，然后需要进入EntryList重新竞争锁
obj.notifyAll() 会唤醒所有在waitset中的线程，然后需要进入EntryList重新竞争锁

case：

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(2);
        log.debug("唤醒 obj 上其它线程");
        synchronized (obj) {
//            obj.notify(); // 唤醒obj上一个线程
            obj.notifyAll(); // 唤醒obj上所有等待线程
        }
    }

wait(long n)和wait()的区别是，前者是有时限的等待，时间到后自己进入EntryList中，后者如果没有notify()或notifyAll()唤醒则进入永久等待。

3.wait notify 的正确姿势

开始之前先看看sleep()和wait()方法有什么区别？

  • sleep()是Thread的静态方法，而wait()方法是Object类下的方法
  • sleep()方法不需要与synchronized配合使用，但是wait()方法必须和sysnchronized配合才能使用
  • 调用sleep()方法，对象不会释放锁，调用wait()方法时对象会释放锁
  • 相同点就是调用两个方法后，线程的状态都是TIMED_WAITING状态

case one:观察下面例子，有什么不妥的地方吗？

@Slf4j(topic = "c.TestWaitNotify")
public class TestWaitNotify {
    final static Object room = new Object();
    static boolean hasCigarette = 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();

        //其它5个人
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("可以开始干活了");
                }
            }, "其它人").start();
        }

        //送烟人
        sleep(1);
        new Thread(() -> {
            // 这里能不能加 synchronized (room)？
            hasCigarette = true;
            log.debug("烟到了噢！");
        }, "送烟的").start();
    }
}

输出：
在这里插入图片描述

不妥之处：

1. 在小南线程睡咩后，由于sleep()方法没有释放锁，导致其余5个人和送烟人都无法执行代码
2. 送烟人已经送到了，小南还在睡
3. 其它干活的线程，都要一直阻塞，效率太低

解决办法：使用wait()/notify()方法

case two：改进case one

public class TestWaitNotify {
    final static Object room = new Object();
    static boolean hasCigarette = false;


    public static void main(String[] args) {

        //小南
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        room.wait(20000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小南").start();

        //其它5个人
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("可以开始干活了");
                }
            }, "其它人").start();
        }

        //送烟人
        sleep(1);
        new Thread(() -> {
            // 这里能不能加 synchronized (room)？
            synchronized (room){
                hasCigarette = true;
                room.notify();
                log.debug("烟到了噢！");
            }

        }, "送烟的").start();
    }
}

输出：
在这里插入图片描述
使用wait()/notify()方法的确解决了case one的问题，但是这样也是存在弊端的，例如如果存在多个等待者呢？

case three：引入多个等待者

public class TestWaitNotify {
    final static 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("可以开始干活了");
                }
            }
        }, "小南").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();
    }
}

输出：
在这里插入图片描述
出现了一种特殊情况，就是我送外卖的唤醒的room.notify();却是等烟的小南，这也是不正常的现象，出现该问题就是两个线程拥有了room对象并且进入了waitset，此时就不明确哪一个会被唤醒了。

但是如果使用notifyAll()方法去唤醒的话，会唤醒两个线程小南，小女，此时这样也不符合我们预期，我们只需要小女，不需要唤醒小南！

最终解决方法：

public class TestWaitNotify {
    final static 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("可以开始干活了");
                }
            }
        }, "小南").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();
    }
}

输出：
在这里插入图片描述

将不去唤醒的线程在wait()外层用while()去处理，但满足某种条件说明改线程要去唤醒，此时while()就可以退出了，符合我们的预期。

synchronized(lock) {
 while(条件不成立) {
 lock.wait();
 }
 // 干活
}
//另一个线程
synchronized(lock) {
 lock.notifyAll();
}

学习资料：https://www.bilibili.com/video/BV16J411h7Rd?p=96

米兰的小铁匠z
关注
专栏目录
【java】java wait 原理 synchronized ReentrantLock 唤醒顺序
九师兄
03-20 1391
学习一网友交流请问下，synchronized大并发的情况下，等待区的线程entrySet和waitSet里的线程分别对应Thread的哪个状态啊，都是wating吗？entryList是blocking状态吧，waitSet是waiting状态线程的生命周期，blocking和waiting不是同一种状态吗总结如下：synchronized关键字的调用wait方法进入等到的线程和因为拿不到锁而等待线程是否同一种状态？blocking？waiting？
【面试：并发篇16：多线程：wait/notify详解】原理及错误用法(虚假唤醒等)
m0_71229547的博客
07-17 862
我们之前学习的过程中浅显的了解过wiat/notify，但是没有系统的介绍过wait/notify，wait是使线程陷入等待notify是随机唤醒一个被wait的线程。obj.wait()wait方法让进入object监视器的线程到waitSet等待。wait后会释放对象锁，让其他线程竞争wait的有时限方法，如果在时限内没有其他线程唤醒，则自己直接唤醒自己，若期间有别的线程唤醒那就正常唤醒。wait后会释放对象锁，让其他线程竞争notify方法让正在waitSet等待的线程挑一个唤醒结果解释。...
【java并发】 --wait与notify原理
十年磨一剑，沉淀……
09-04 4923
重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实 现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。前面我们在讲Java对象头的时候，讲到了monitor这个对象，在hotspot虚拟机中，通过ObjectMonitor类来实现monitor。他的锁的获取过程的体现会简单很多. wait 和notif...
JAVA系列：wait和notify的工作原理
NIO4444
09-05 1241
调用wait方法，首先会获取监视器锁，获得成功以后，会让当前线程进入等待状态进入等待队列并且释放锁； 然后 当其他线程调用notify或者notifyall以后，会选择从等待队列中唤醒任意一个线程，而执行完notify方法以后，并不会立马唤醒线程，原因是当前的线程仍然持有这把锁，处于等待状态的线程无法获得锁。必须要等到当前的线程执行完按monitorexit指令以后，也就是锁被释放以后，处于等待队列中的线程就可以开始竞争锁了。 ...
深入探究Java中wait/notify机制的工作原理
最新发布
Reische的博客
11-04 272
Java 线程通信是将多个独立的线程个体进行关联处理，使得线程与线程之间能进行相互通信。比如线程 A 修改了对象的值，然后通知给线程 B，使线程 B 能够知道线程 A 修改的值，这就是线程通信。
Java并发编程-wait和notify原理剖析
Java硬件工程师的博客
02-05 2194
1.小故事 - 为什么需要 wait 有一对小孩都要使用算盘CPU进行计算，为了计算过程中的计算安全，老王设计了一个synchronized锁，让每个时刻只有一个线程进入房间成为owner的主人。这样只能排队一个一个线程的来，从而保证计算过程中的线程安全。 由于条件不满足，小南不能继续进行计算(比如他必须要叼根烟，有烟才能进行计算) 但小南如果一直占用着锁，其它人就得一直阻塞，效率太低 于是老王单开了一间休息室（调用 wait 方法），让小南到休息室（WaitSet）等着去了，但这时锁释放开，其它人可以由
浅谈java多线程wait，notify
08-25
_java多线程wait、notify机制详解_ 在Java多线程编程中，wait和notify是两个非常重要的机制，用于实现线程之间的通信和同步。在本文中，我们将通过示例代码详细介绍Java多线程wait和notify的使用，帮助读者更好地...
浅谈Java线程间通信之wait/notify
08-30
wait/notify机制是Java多线程编程中非常重要的一部分，掌握它可以帮助我们更好地编写高效、可靠的多线程程序。 Java线程间通信之wait/notify的优点： * 提高程序的效率和可靠性 * 避免了不断地循环和资源浪费 * ...
Java多线程-wait/notify机制
LifeBackwards的专栏
04-10 135
等待/通知（wait/notify）机制 一 等待/通知机制介绍 1.1 不使用等待/通知机制 当两个线程之间存在生产和消费者关系，也就是说第一个线程（生产者）做相应的操作然后第二个线程（消费者）感知到了变化又进行相应的操作。比如像下面的whie语句一样，假设这个value值就是第一个线程操作的结果，doSomething()是第二个线程要做的事，当满足条件value=desire后才...
Java线程状态与线程通讯wait/notify，park/unpark机制
Der_Dream的博客
05-13 1059
Java线程状态 Java线程共有6个状态，在java.lang.Thread.State中明确定义。 线程状态图： 1.NEW 尚未启动的线程的状态 2.Runnable 可运行的线程的状态，包括等待CPU调度和正在运行的线程的状态 3.Blocked 等待监视器锁的阻塞线程的状态，处于synchronized同步代码块或方法中被阻塞 4.Waiting 等待线程的状态。...
java notify唤醒原理_Java wait和notify虚假唤醒原理
weixin_39718890的博客
02-19 135
自己在此记录一下，方便日后复习。虚假唤醒的概念jdk官方文档解释：所以说在wait和notify一块使用时，如果使用if作为条件时，会有虚假唤醒的情况发生，所以必须使用while作为循环条件。下面来举例实验：首先，创建一个资源类：(在多线程中，一般都是资源类和线程操作解耦，不放在用同一个类中，只有在线程操作资源类时，才会创建资源类的对象)package com.test;/*** 资源类* @au...
详解 Java 中的 Wait 和 Notify 机制
旧时光 | YoungChen's 博客
02-26 2683
写在前面 Wait 和 Notify 是 Java 面试中常见的问题，但是在平时工作中可能不常见到。大家或多或少知道些背景知识，例如二者均为 Object 类的方法，而不是 Thread 特有的（因为锁是每个对象都具有的特性，因此操作锁的方法也紧跟对象，没毛病），且都只能在同步代码块中调用（即前提是先获得对象的监视器锁，一般来说在 synchronized 代码块中使用），否则抛出异常 Illeg...
Java并发编程之wait、notify和join原理
从基础到源码解析的学习记录
02-12 1393
文章目录1、wait、notify介绍2、API介绍3、sleep(long n) 和 wait(long n)的区别4、wait/notify的正确使用# 2、join源码3、park & unpack3.1、基本使用3.2、 park、 unpark 原理4、线程状态转换 1、wait、notify介绍 必须要获取到锁对象, 才能调用这些方法 当线程0获得到了锁, 成为Monitor的Owner, 但是此时它发现自己想要执行synchroized代码块的条件不满足; 此时它就调用obj.wa
java中wait/notify机制
叶落伤城的专栏
08-08 1315
通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。 以上逻辑
通俗的解释JAVA wait/notify机制
weixin_30394251的博客
03-28 105
生活中，我们常遇到需要等待的场景，例如去银行办事，在没轮到自己之前需要一直等待，但是如果需要自己每隔几秒钟就去柜台前看看状况，那肯定是种非常低效和令人恼火的体验。而实际的情况是，接待员会让您拿个号，说"请稍等一会"(wait); 当排到时，语言和大屏幕会提示"请XXX号到N号柜台办理"(notify)。 wait/notify机制也正是处理这样的场景：线程继续执行需要等待某个条件的变化，...
Java多线程通讯之wait,notify的区别详解
08-27
Java多线程通讯之wait、notify的区别详解 Java多线程通讯是指在多线程编程中，线程之间如何进行通讯和同步的问题。其中，wait和notify是两个非常重要的方法，用于控制线程的状态和同步。 wait方法： wait方法是...
Java wait和notify虚假唤醒原理
08-19
主要介绍了Java wait和notify虚假唤醒,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java并发（五）wait/notify的使用和简单原理
baldist的博客
11-02 205
一.使用 class Add implements Runnable { static Integer num=0; Object obj; public Add(Object obj) { this.obj=obj; } @Override public void run() { synchronized (obj) { for (int i=0;i<100;i
java的Object里wait()实现原理
热门推荐
ZytheMoon的博客
04-22 1万+
在进行wait()之前，就代表着需要争夺Synchorized，而Synchronized代码块通过javap生成的字节码中包含monitorenter和monitorexit两个指令。在进如锁的时候会执行monitorenter，执行monitorenter指令可以获取对象的monitor。同时在执行Lock.wait()的时候也必须持有monitor对象。 在多核环境下，多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值