虚假唤醒问题

已于 2022-03-17 00:03:21 修改
阅读量1.8k 收藏 11
点赞数 3
分类专栏： java技术要点 文章标签： java 多线程 并发编程 wait 虚假唤醒
于 2020-01-31 22:16:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/at10090/article/details/104127662
版权

虚假唤醒问题

是一种在多线程环境下出现的问题,本文将一步步进行解释和解决.

生成者与消费者案例

下面是使用synchronized关键字进行加锁,实现线程不安全问题的生产者与消费者案例.

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2020/1/31 19:48
 */
//主方法
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer pro = new Producer(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro,"生产者A").start();
        new Thread(cus,"消费者B").start();
    }
}
//仓库类
class Clerk {
    private int product = 0;

    //进货
    public synchronized void get() {
        if (product >= 10) {
            System.out.println("仓库已满");
        } else {
            System.out.println(Thread.currentThread().getName() + ":" + ++product);
        }

    }

    //卖货
    public synchronized void sale() {
        if (product <= 0) {
            System.out.println("缺货");
        } else {
            System.out.println(Thread.currentThread().getName() + ":" + --product);
        }
    }
}

//生产者类producer
class Producer implements Runnable {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.get();
        }
    }
}

//消费者类
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

然后就会出现下面图片类似的情况,在没有使用等待唤醒机制的情况下,会存在俩个线程无法同步进行的问题,造成生成者不断生成,而消费者一直消费,两者无法统一进行,这是不合理的,也会造成性能的损坏.
在这里插入图片描述
在采用等待唤醒机制,下面是使用Object的sleep()和wait()方法进行实现.

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2020/1/31 19:48
 */
//主方法
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer pro = new Producer(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者A").start();
        new Thread(cus, "消费者B").start();
    }
}

//仓库类
class Clerk {
    private int product = 0;

    //进货
    public synchronized void get() {
        if (product >= 10) {
            System.out.println("仓库已满");
            try {
                //在仓库已满时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        } else {
            System.out.println(Thread.currentThread().getName() + ":" + ++product);
            //当仓库内存在货物时,通知线程可以进行卖货了
            this.notifyAll();
        }

    }

    //卖货
    public synchronized void sale() {
        if (product <= 0) {
            System.out.println("缺货");
            try {
                //在仓库缺货时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        } else {
            System.out.println(Thread.currentThread().getName() + ":" + --product);
            //通知线程可以进行进货了,存在空位
            this.notifyAll();
        }
    }
}

//生产者类
class Producer implements Runnable {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.get();
        }
    }
}

//消费者类
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

在这里插入图片描述

这种方式在俩个线程并生产者与消费者各为一个线程时是不存在虚假唤醒问题的.但是还是存在问题

在生产者的代码中加上0.2秒的网络延时

@Override
public void run() {
    for (int i = 0; i < 20; i++) {
        //存在延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        clerk.get();
    }
}

就会可能出现如下图这种情况(将货物空位调整为1,方便查看),在咋一看没有什么问题?(注意是有概率出现该错误)

然而问题在于该程序并没有结束,还是持续运行!

在这里插入图片描述

为什么会出现这种情况呢?

因为在消费者或者是生产者二者所剩余的次数不一致时出现的问题,如上图消费者已经使用完了他的消费次数,而生成者并未使用完,而当生产者生成到仓库满了时就会进行等待唤醒,然而消费者线程已经使用完了(也就是该线程已经死亡)没有线程会将生成者线程唤醒,所以就会出现无限等待的情况.

如何解决这个无限等待问题呢?

解决的办法非常简单,那就是在方法的最后都进行唤醒所有线程的方法.

具体代码如下:

//仓库类
class Clerk {
    private int product = 0;

    //进货
    public synchronized void get() {
        if (product >= 1) {
            System.out.println("仓库已满");
            try {
                //在仓库已满时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + ++product);
        //当仓库内存在货物时,通知线程可以进行卖货了
        this.notifyAll();

    }

    //卖货
    public synchronized void sale() {
        if (product <= 0) {
            System.out.println("缺货");
            try {
                //在仓库缺货时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + --product);
        //通知线程可以进行进货了,存在空位
        this.notifyAll();
        
    }
}

由于一旦出现库满或者缺货都会进行等待唤醒,所以去除else就可以了,不会造成缺货还进行卖货操作(俩个线程情况下)

然而在多个生成者和消费者的情况下会出现虚假唤醒问题.(就是会出现缺货还进行卖货操作等)

将主线程的方法修改为如下:

public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer pro = new Producer(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者A").start();
        new Thread(cus, "消费者B").start();
        new Thread(pro, "生产者C").start();
        new Thread(cus, "消费者D").start();
    }
}

会出现如下情况
在这里插入图片描述

为什么会出现这种情况呢?

因为在缺货情况下,俩条线程同时进行一条进行等待唤醒,而另一个线程则还在进行卖货操作.

如:当线程B消费时货物还有1个

在这里插入图片描述

造成D，B线程被异常的唤醒,而再进行消费时D线程会以同样的方式唤醒B线程,当俩个线程同时进行等待唤醒时(即不再按照这个流程进行获取对象锁),才不会再继续下去

那么如何解决虚假唤醒问题呢?

其实在jdk的API文档中就说明了该问题,官方推荐使用whlie对wait()进行包裹
在这里插入图片描述
这样就不会出现虚假唤醒问题了

下面是测试的代码:

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2020/1/31 19:48
 */
//主方法
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer pro = new Producer(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者A").start();
        new Thread(cus, "消费者B").start();
        new Thread(pro, "生产者C").start();
        new Thread(cus, "消费者D").start();
    }
}

//仓库类
class Clerk {
    private int product = 0;

    //进货
    public synchronized void get() {
        while (product >= 1) {
            System.out.println("仓库已满");
            try {
                //在仓库已满时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + ++product);
        //当仓库内存在货物时,通知线程可以进行卖货了
        this.notifyAll();

    }

    //卖货
    public synchronized void sale() {
        while (product <= 0) {
            System.out.println("缺货");
            try {
                //在仓库缺货时才进行等待
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + --product);
        //通知线程可以进行进货了,存在空位
        this.notifyAll();

    }
}

//生产者类
class Producer implements Runnable {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //存在延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            clerk.get();
        }
    }
}

//消费者类
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}
嘿嘿嘿1212
关注
专栏目录
Java JUC 高级线程之七 虚假唤醒产生的原因解决方案
码农回顾
03-31 1158
文章目录为什么会产生虚假唤醒?解决方案 为什么会产生虚假唤醒? Object.wait()当我们运行到这个方法的时候，当前线程会进入等待状态，并释放锁，而当其他线程去唤醒它的时候，它会之后wait()的地方继续开始执行。 Object.notifyAll() 会唤醒所有处于等待状态的线程抢夺线程锁，所以两个线程会重新抢锁。 当只有单个生产者和单个消费者的时候和 使用 if - else，产生虚假...
Java多线程之虚假唤醒（原创）
Cratels学编程
03-31 1822
Java多线程之虚假唤醒 文章目录Java多线程之虚假唤醒虚假唤醒的定义从`生产者-消费者`场景讲起单生产者-单消费者场景多生产者-多消费者场景这就是虚假唤醒吗？ 首先需要说明的是，虚假唤醒不是Java语言特有的问题，而是多线程通信特有的问题，在java中就体现在sychronized-wait-notify上，最典型的应用场景就是生产者-消费者模式。 在网上翻看了很多关于虚假唤醒的文档，才发现大多数人说的都是错的。要么语焉不详，要么南辕北辙，不一而足。于是我决定自己写一篇文章来说一说：到底什么是虚假唤醒？
虚假唤醒
最新发布
weixin_35980267的博客
07-01 53
虚假唤醒是一种在多线程编程中可能出现的现象，指的是在等待特定条件满足的线程被唤醒，但这个唤醒并不是由于条件变量的信号（如pthread_cond_signal或notify_one/signal_one等方法）直接导致的。换句话说，即使没有对线程进行显式的唤醒操作，线程也可能因为某些原因（如操作系统的内部行为）被唤...
虚假唤醒分析
qq_43481605的博客
05-05 1132
一、虚假唤醒解读 首先我们要明白 if 和 while的区别 先直接看while和if的区别 可以看出来,if 是true情况下,if内的代码也只会执行一次 而while直至不满足条件才能跳出while循环 先分析while情况下 public class Demo { public static void main(String[] args) { Products data = new Products(); new Thread(() -> {
java线程虚假唤醒_JAVA线程虚假唤醒
weixin_33893979的博客
02-16 151
JAVA线程虚假唤醒线程虚假唤醒问题描述​ 在JDK API文档中，关于Object类的wait()方法有这样一句话描述"线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待"，如下图所示： ​ 在多线程的情况下，当多个线程执行了wait()方法后，需要其它线程执行notify()...
【小家java】JUC并发编程之：虚假唤醒以及推荐的解决方案.docx
10-26
### JUC并发编程中的虚假唤醒及其解决方案 #### 一、虚假唤醒的概念与...通过以上分析和解决方案的介绍，可以看出，在Java并发编程中，合理地处理虚假唤醒是非常重要的，它可以有效避免因线程同步不当而导致的问题。
Java wait和notify虚假唤醒原理
08-19
总的来说，Java中的`wait()`和`notify()`是实现线程间同步和通信的重要工具，但需要注意虚假唤醒的问题，确保使用`while`循环检查条件，以提供可靠的同步机制。同时，合理设计线程的交互逻辑和同步策略，如使用`...
虚假唤醒和原子操作
weixin_45983489的博客
03-10 231
一、虚假唤醒： notify_one()或者notify_all()唤醒wait()后，实际有些线程可能不满足唤醒的条件：例如使用 notify_one() 两个线程在启动时的第一次唤醒，例如在使用 notify_all() 时多个线程都被唤醒共享区却只有满意少数线程操作，这时就会造成其他线程被虚假唤醒，可以在wait中再次进行判断解决虚假唤醒。 解决：wait中要有第二个参数（lambda），并且这个lambda中要正确判断所处理的公共数据是否存在。 例如：（通过lambda进行判断防止虚假唤醒） my
C/C++多线程之虚假唤醒
qq_38988226的博客
10-29 3259
多线程之虚假唤醒 首先介绍几个函数，是多线程中关于条件变量的： pthread_cond_wait int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex); //成功，返回0; 失败，返回错误编号 该函数的主要作用是，将线程放置等待线程队列上，然后阻塞，等待条件发生唤醒线程。其执行步骤如下： 利用 mutex 对 cond 加锁; 进入函数; 将该线程放至条件等待线程队列上; 利用 mutex
多线程虚假唤醒问题
球球你被学了的博客
02-26 446
1、什么是虚假唤醒？ 虚假唤醒就是在多线程执行过程中，线程间的通信未按照我们幻想的顺序唤醒，故出现数据不一致等不符合我们预期的结果。比如 我的想法是：加1和减1交替执行，他却出现了2甚至3这种数：请看下面例子： 假设有四个线程A、B、C、D同时启动，我们定义A和B为加法线程，C和D为减法线程，每个线程执行5次回到原点，我们的期望结果是：0，1，0，1，0，1…0，1，0 顺此进行，但执行结果却是： [](javascript:void(0)😉 package ldk.test; /** * @Auth
Java虚假唤醒
qq_43274869的博客
09-11 462
我们知道在synchronized中使用wait和notify会产生虚假唤醒的问题,使用while代替if就可以解决虚假唤醒 具体原因是我们学习wait和notify的时候没有理解清楚,注意:notify之后被唤醒的那个线程会接执行而不是重新执行 ...
java线程虚假唤醒
Never too late!
04-05 1513
public class MyStack {           private List list = new ArrayList();                  public synchronized void push(String value) {               synchronized (this) {                   list.add
虚假唤醒详解
horacen的博客
04-28 6846
虚假唤醒详解        接触过多线程编程的朋友们或多或少都听说过虚假唤醒这一术语，我在百度上看了很多相关的帖子，说的都不是很清楚，于是写下这篇文章，希望能对大家有些裨益。 虚假唤醒是什么        首先我们来谈谈虚假唤醒到底是什么。在这里我给出一个自己的定义，帮助大家去理解虚假唤醒 虚假唤醒是一种现象，它只会出现在多线程环境中，指的是在多线程环境下，多个线程等
虚假唤醒以及解决
qq_47711757的博客
07-29 339
虚拟唤醒问题，lock解决
Java wait与notify：理解虚假唤醒现象
本文主要探讨了Java中的wait和notify机制，特别是关于虚假唤醒的问题，并提供了相关的示例代码来说明。 在Java多线程编程中，`wait()` 和 `notify()` 是对象锁的一部分，它们用于线程间的通信和同步。这两个方法都...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嘿嘿嘿1212

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

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

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

打赏作者

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

抵扣说明：

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

余额充值