Java并发编程-wait和notify原理剖析

最新推荐文章于 2023-11-04 13:41:58 发布
最新推荐文章于 2023-11-04 13:41:58 发布
阅读量2.1k 收藏 8
点赞数 4
分类专栏： 并发编程 Java 多线程 文章标签： 并发编程 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39736597/article/details/113696474
版权
Java 同时被 3 个专栏收录
211 篇文章 12 订阅
订阅专栏
多线程
20 篇文章 3 订阅
订阅专栏
并发编程
19 篇文章 1 订阅
订阅专栏

目录

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

有一对小孩都要使用算盘CPU进行计算，为了计算过程中的计算安全，老王设计了一个synchronized锁，让每个时刻只有一个线程进入房间成为owner的主人。这样只能排队一个一个线程的来，从而保证计算过程中的线程安全。

由于条件不满足，小南不能继续进行计算(比如他必须要叼根烟，有烟才能进行计算)
但小南如果一直占用着锁，其它人就得一直阻塞，效率太低
在这里插入图片描述
于是老王单开了一间休息室（调用 wait 方法），让小南到休息室（WaitSet）等着去了，但这时锁释放开，其它人可以由老王随机安排进屋
直到小M将烟送来，大叫一声 [ 你的烟到了 ] （调用 notify 方法）
在这里插入图片描述
小南于是可以离开休息室，重新进入竞争锁的队列
在这里插入图片描述

2.wait & notify工作原理

在这里插入图片描述
Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
BLOCKED 线程会在 Owner 线程释放锁时唤醒
WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入
EntryList 重新竞争
waiting状态必须要获得锁才能进入等待状态。

3.API 介绍

obj.wait()让进入 object 监视器的线程到 waitSet 等待
obj.notify()在 object 上正在 waitSet 等待的线程中挑一个唤醒
obj.notifyAll()让 object 上正在 waitSet 等待的线程全部唤醒
它们都是线程之间进行协作的手段，都属于 Object 对象的方法。必须获得此对象的锁，才能调用这几个方法

我们可以测试一下

public class TestWait {
    static final Object lock=new Object();
    public static void main(String[] args) {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Exception in thread "main" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at cn.yj.jvm.TestWait.main(TestWait.java:7)

报了IllegalMonitorStateException，所以我们必须要先获得锁，才能进入等待状态。
以下代码即可运行成功

static final Object lock=new Object();
public static void main(String[] args) {
    synchronized (lock){
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们可以看看下面代码

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

.public final void wait() throws InterruptedException {
        wait(0);
    }

wait无参时调用了一个wait(0)，0表示无限制等待，直到有线程调用notify方法，才会被唤醒。

public final native void wait(long timeout) throws InterruptedException;

4.wait和notify的正确姿势

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

  1. sleep 是 Thread 方法，而 wait 是 Object 的方法
  2. sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用，即wait必须要获得对象锁才能使用。
  3. sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁
  4. 它们的状态 都是TIMED_WAITING

从下面的程序可以看到，主线程要等到t1线程释放锁才能执行synchronized中的语句。

public class TestLLock12 {
    //保证引用不会再变，从而synchronized的锁的都是同一个对象
    static final Object obj=new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized(obj){
                try {
                    System.out.println("t1获得锁");
                    Thread.sleep(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1").start();
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (obj){
            System.out.println("主线程获得锁");
        }
    }
}

而将sleep改成wait时

synchronized(obj){
                try {
                    System.out.println("t1获得锁");
                    obj.wait(200000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 }

它会很快的释放锁，然后下面的主线程中的同步代码块中的语句会很快得到执行。这样wait的效率就会更高一些

4.2.step1

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();
}
sleep(1);
new Thread(() -> {
    // 这里能不能加 synchronized (room)？
    hasCigarette = true;
    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 机制

4.3.step2

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

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();

输出

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 - 可以开始干活了
  • 解决了其它干活的线程阻塞的问题
  • 但如果有其它线程也在等待条件呢？

4.4.step3

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.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

4.5.step4

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

4.6.step5

将 if 改为 while

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

改动后

public static void main(String[] args) {
    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 - 没烟，先歇会！

4.7.正确套路模板

public class Copy {
    synchronized(lock) {
        while(条件不成立) {
            lock.wait();
        }
        // 干活
    }
    //另一个线程
    synchronized(lock) {
        lock.notifyAll();
    }
}
Java硬件工程师
关注
专栏目录
【java并发】 --wait与notify原理
十年磨一剑，沉淀……
09-04 4921
重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实 现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。前面我们在讲Java对象头的时候，讲到了monitor这个对象，在hotspot虚拟机中，通过ObjectMonitor类来实现monitor。他的锁的获取过程的体现会简单很多. wait 和notif...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
Java多线程wait/notify原理
LIUZEYU12A
01-30 969
1. 引入wait/notify 回顾：在之前的学习中，当我们创建一个对象后，synchronized给对象上锁，JVM会给对象头关联一个Monitor对象，这个Monitor由三部分组成。 一是Owner对象，里面存储的是创建该对象的线程 二是EntryList，想试图获取该对象资源的其它堵塞线程队列 三是WaitSet，存储的是放弃对象锁的线程 Owner线程中的锁对象，如果发现条件不满足，调用wait()方法，既可以进入到WaitSet变为WAITING状态 EntryList下和WaitSet下
深入探究Java中wait/notify机制的工作原理
最新发布
Reische的博客
11-04 272
Java 线程通信是将多个独立的线程个体进行关联处理，使得线程与线程之间能进行相互通信。比如线程 A 修改了对象的值，然后通知给线程 B，使线程 B 能够知道线程 A 修改的值，这就是线程通信。
java notify唤醒原理_Java wait和notify虚假唤醒原理
weixin_39718890的博客
02-19 135
自己在此记录一下，方便日后复习。虚假唤醒的概念jdk官方文档解释：所以说在wait和notify一块使用时，如果使用if作为条件时，会有虚假唤醒的情况发生，所以必须使用while作为循环条件。下面来举例实验：首先，创建一个资源类：(在多线程中，一般都是资源类和线程操作解耦，不放在用同一个类中，只有在线程操作资源类时，才会创建资源类的对象)package com.test;/*** 资源类* @au...
JAVA系列：wait和notify的工作原理
NIO4444
09-05 1241
调用wait方法，首先会获取监视器锁，获得成功以后，会让当前线程进入等待状态进入等待队列并且释放锁； 然后 当其他线程调用notify或者notifyall以后，会选择从等待队列中唤醒任意一个线程，而执行完notify方法以后，并不会立马唤醒线程，原因是当前的线程仍然持有这把锁，处于等待状态的线程无法获得锁。必须要等到当前的线程执行完按monitorexit指令以后，也就是锁被释放以后，处于等待队列中的线程就可以开始竞争锁了。 ...
java-wait和notify的用法.pdf
11-15
在Java编程语言中，`wait()`和`notify()`是Object类中的两个关键方法，它们用于线程间的协作和通信。这两个方法在多线程环境下尤其重要，因为它们允许线程等待特定条件并通知其他线程继续执行。在分析给定的程序之前...
java并发编程-构建块
05-24
6. **线程通信**：Java提供了多种线程间通信的方式，如`wait()`, `notify()`和`notifyAll()`，它们基于对象的监视器（monitor）。此外，`java.util.concurrent`包中的`BlockingQueue`接口和其实现如`...
Java并发编程-线程安全与基础构建模块
04-04
在Java编程领域，多线程并发是不可或缺的一部分，特别是在服务器端和高并发应用中。本文将深入探讨"Java并发编程-线程安全与基础构建模块"这一主题，旨在帮助开发者理解如何有效地处理并发问题，提高程序性能和稳定...
java并发编程艺术源码-ArtConcurrentBook:《Java并发编程的艺术》
05-25
《Java并发编程的艺术》是一本深入探讨Java多线程与并发编程的经典著作，它涵盖了Java并发编程中的核心概念和技术。源码ArtConcurrentBook提供了书中示例代码的详细实现，对于学习和理解Java并发编程有着极大的帮助...
详解Java程序并发的Wait-Notify机制
09-03
主要介绍了详解Java程序并发的Wait-Notify机制,多线程并发是Java编程中的重要部分,需要的朋友可以参考下
Java wait和notify虚假唤醒原理
08-19
主要介绍了Java wait和notify虚假唤醒,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解 Java 中的 Wait 和 Notify 机制
旧时光 | YoungChen's 博客
02-26 2683
写在前面 Wait 和 Notify 是 Java 面试中常见的问题，但是在平时工作中可能不常见到。大家或多或少知道些背景知识，例如二者均为 Object 类的方法，而不是 Thread 特有的（因为锁是每个对象都具有的特性，因此操作锁的方法也紧跟对象，没毛病），且都只能在同步代码块中调用（即前提是先获得对象的监视器锁，一般来说在 synchronized 代码块中使用），否则抛出异常 Illeg...
Java中的对象Object方法之---wait()和notifiy()
chupu2979的博客
06-24 151
上一篇说到了suspend()和resume()方法，这一篇咋们继续，接着来介绍wait()和notify()方法，我们都知道这两个方法和之前介绍的方法不太一样，那就是这两个方法是对象Object上的，不属于Thread类上的。我们也知道这两个方法是实现多个线程之间的通信和互斥的，不多说了，...
通俗的解释JAVA wait/notify机制
weixin_30394251的博客
03-28 105
生活中，我们常遇到需要等待的场景，例如去银行办事，在没轮到自己之前需要一直等待，但是如果需要自己每隔几秒钟就去柜台前看看状况，那肯定是种非常低效和令人恼火的体验。而实际的情况是，接待员会让您拿个号，说"请稍等一会"(wait); 当排到时，语言和大屏幕会提示"请XXX号到N号柜台办理"(notify)。 wait/notify机制也正是处理这样的场景：线程继续执行需要等待某个条件的变化，...
java的Object里wait()实现原理
热门推荐
ZytheMoon的博客
04-22 1万+
在进行wait()之前，就代表着需要争夺Synchorized，而Synchronized代码块通过javap生成的字节码中包含monitorenter和monitorexit两个指令。在进如锁的时候会执行monitorenter，执行monitorenter指令可以获取对象的monitor。同时在执行Lock.wait()的时候也必须持有monitor对象。 在多核环境下，多个...
Java多线程中的 wait() 和 notify() 方法
sinat_31583645的博客
03-17 3162
多线程并发的场景下，有时需要某些线程先执行，这些线程执行结束后其他线程再继续执行, wait()和notify()是Object类的方法，用于线程的等待与唤醒，必须搭配synchronized 锁来使用。
java中wait/notify机制
叶落伤城的专栏
08-08 1315
通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。 以上逻辑
Java并发编程—线程间协作方式wait()/notify()/notifyAll()原理分析
sanmi8276的博客
02-24 286
原文作者：tom有了cat 原文地址：java并发编程基础之等待通知机制wait/notify原理分析 一个线程修改了一个对象的值，而另一个线程感知了变化，然后进行了相应的操作，整个过程开始于一个线程，结束于另一个线程。前者是生产者，后者是消费者，这种模式在功能层面上实现了解耦。有下面一段代码，大家可以根据执行的结果和注释很清晰的明确这个wait和notify的工作机制，wait等待释放锁。代码如下，不再做具体描述： package juc.waitsleep; /** * @Descri.
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值