6.JUC-线程的虚假唤醒-生产者和消费者

最新推荐文章于 2022-10-17 22:09:41 发布
最新推荐文章于 2022-10-17 22:09:41 发布
阅读量128 收藏
点赞数
分类专栏： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44124307/article/details/102517676
版权

一）经典案例生产者和消费者

存在问题：
在经典的案例生产者和消费者中存在了一个很大的问题，当生产者生产的消息过快或者是消费者消费的消息过快容易出现数据丢失的问题。

解决方法：等待唤醒机制

演示生产者消费者案例

/**
 * @project_name:juc
 * @date:2019/9/27:21:06
 * @author:shinelon
 * @Describe:生产者和消费者案例
 */
public class TestProductAndConsumer
{
    public static void main(String[] args)
    {
        Check check = new Check();
        Product product = new Product(check);
        Consumer consumer = new Consumer(check);
        new Thread(product,"生产者A").start();
        new Thread(consumer,"消费者B").start();
    }
}

class Check
{

    private int product = 0;

    /**
     * 添加商品
     */
    public synchronized void add()
    {
        if (product >=20)
        {
            System.out.println("商品已满");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println(Thread.currentThread().getName() + "增加商品:" + ++product);
            this.notifyAll();
        }
    }


    /**
     * 消费
     */
    public synchronized void reduce()
    {
        if (this.product <= 0)
        {
            System.out.println("商品以空");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println(Thread.currentThread().getName() + "目前正在消费:" + --product);
            this.notifyAll();
        }
    }
}

/**
 * 生产者
 */
class Product implements Runnable
{
    private Check check;

    public Product(Check check)
    {
        this.check = check;
    }


    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            this.check.add();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable
{
    private Check Check;

    public Consumer(Check Check)
    {
        this.Check = Check;
    }

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

            this.Check.reduce();
        }
    }
}

在这里插入图片描述

二）虚假唤醒的演示

演示虚假唤醒之间需要先演示的一个的线程不结束的问题
1.给生产者加上0.2秒的延迟
2.给生产的数量改为1

/**
 * @project_name:juc
 * @date:2019/9/27:21:06
 * @author:shinelon
 * @Describe:生产者和消费者案例
 */
public class TestProductAndConsumer
{
    public static void main(String[] args)
    {
        Check check = new Check();
        Product product = new Product(check);
        Consumer consumer = new Consumer(check);
        new Thread(product,"生产者A").start();
        new Thread(consumer,"消费者B").start();
    }
}

class Check
{
    private int product = 0;

    /**
     * 添加商品
     */
    public synchronized void add()
    {
        if (product >=1)
        {
            System.out.println("商品已满");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println(Thread.currentThread().getName() + "增加商品:" + ++product);
            this.notifyAll();
        }
    }


    /**
     * 消费
     */
    public synchronized void reduce()
    {
        if (this.product <= 0)
        {
            System.out.println("商品以空");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println(Thread.currentThread().getName() + "目前正在消费:" + --product);
            this.notifyAll();
        }
    }
}

/**
 * 生产者
 */
class Product implements Runnable
{
    private Check check;

    public Product(Check check)
    {
        this.check = check;
    }


    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep(200);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.check.add();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable
{
    private Check Check;

    public Consumer(Check Check)
    {
        this.Check = Check;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            this.Check.reduce();
        }
    }
}

出现程序不能够正常的结束

在这里插入图片描述

原因分析：

根据上面的分析首先生产者线程要比消费者线程要慢，假设此时生产者线程剩下2次循环的机会，消费者线程只剩下1次的机会，那么消费者线程在消费完毕后线程结束，而生产者线程在商品大于等于1的时候进入了wait(),此时消费者线程已经结束那么没有线程在去消费商品。

解决的办法把else去掉，这样在等待时候会执行线程的唤醒，不会因为线程不满足条件而不进行线程的唤醒

/**
 * @project_name:juc
 * @date:2019/9/27:21:06
 * @author:shinelon
 * @Describe:生产者和消费者案例
 */
public class TestProductAndConsumer
{
    public static void main(String[] args)
    {
        Check check = new Check();
        Product product = new Product(check);
        Consumer consumer = new Consumer(check);
        new Thread(product, "生产者A").start();
        new Thread(consumer, "消费者B").start();
    }
}

class Check
{
    private int product = 0;

    /**
     * 添加商品
     */
    public synchronized void add()
    {
        if (product >= 1)
        {
            System.out.println("商品已满");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        //去掉else保证线程的正确执行
        System.out.println(Thread.currentThread().getName() + "增加商品:" + ++product);
        this.notifyAll();
    }


    /**
     * 消费
     */
    public synchronized void reduce()
    {
        if (this.product <= 0)
        {
            System.out.println("商品以空");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
           //去掉else保证线程的正确执行
        System.out.println(Thread.currentThread().getName() + "目前正在消费:" + --product);
        this.notifyAll();
    }
}

/**
 * 生产者
 */
class Product implements Runnable
{
    private Check check;

    public Product(Check check)
    {
        this.check = check;
    }


    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep(200);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.check.add();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable
{
    private Check Check;

    public Consumer(Check Check)
    {
        this.Check = Check;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            this.Check.reduce();
        }
    }
}

正常结束：

在这里插入图片描述

2）虚假唤醒演示

现在线程中只用一个生产者和一个消费者线程，线程之间还是很和谐的假如现在分别增加一个生产者和消费者线程

/**
 * @project_name:juc
 * @date:2019/9/27:21:06
 * @author:shinelon
 * @Describe:生产者和消费者案例
 */
public class TestProductAndConsumer
{
    public static void main(String[] args)
    {
        Check check = new Check();
        Product product = new Product(check);
        Consumer consumer = new Consumer(check);
     
        new Thread(product, "生产者A").start();
        new Thread(consumer, "消费者B").start();
        new Thread(product, "生产者C").start();
        new Thread(consumer, "消费者D").start();
    }
}

class Check
{
    private int product = 0;

    /**
     * 添加商品
     */
    public synchronized void add()
    {
        if (product >= 1)
        {
            System.out.println("商品已满");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        //去掉else保证线程的正确执行
        System.out.println(Thread.currentThread().getName() + "增加商品:" + ++product);
        this.notifyAll();
    }


    /**
     * 消费
     */
    public synchronized void reduce()
    {
        if (this.product <= 0)
        {
            System.out.println("商品以空");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "目前正在消费:" + --product);
        this.notifyAll();
    }
}

/**
 * 生产者
 */
class Product implements Runnable
{
    private Check check;

    public Product(Check check)
    {
        this.check = check;
    }


    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep(200);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.check.add();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable
{
    private Check Check;

    public Consumer(Check Check)
    {
        this.Check = Check;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            this.Check.reduce();
        }
    }
}

测试结果就发现此时已经出现问题。

在这里插入图片描述

虚假唤醒的原因分析：

线程在执行的时候生产者和消费者都有两个的线程在进行共享资源的操作，当线程进行操作的时候假设现在消费者BD同时进入了方法内，假设此时B线程失去执行权的话那么在进行D执行消费商品后，线程B获得了执行权继续执行此时依然会在对商品进行消费，按照正常逻辑需要线程B在去判断下是否商品已经没了，如果不对商品进行判断就会出现虚假消费出现负值。这就是虚假唤醒。

虚假唤醒在JDK的帮助帮助文档内是有解决方案的，就是wait()方法的解释下

（有兴趣小伙伴可以去认证下）官方给出的是使用while循环进行解决。将wait()出现在while中

package com.itguigu.juc;


/**
 * @project_name:juc
 * @date:2019/9/27:21:06
 * @author:shinelon
 * @Describe:生产者和消费者案例
 */
public class TestProductAndConsumer
{
    public static void main(String[] args)
    {
        Check check = new Check();
        Product product = new Product(check);
        Consumer consumer = new Consumer(check);
        new Thread(product, "生产者A").start();
        new Thread(consumer, "消费者B").start();
        new Thread(product, "生产者C").start();
        new Thread(consumer, "消费者D").start();
    }
}

class Check
{
    private int product = 0;

    /**
     * 添加商品
     */
    public synchronized void add()
    {

        //解决线程的虚假唤醒，将wait()始终出现在while循环中。
        while (product >= 1)
        {
            System.out.println("商品已满");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        //去掉else保证线程的正确执行
        System.out.println(Thread.currentThread().getName() + "增加商品:" + ++product);
        this.notifyAll();
    }


    /**
     * 消费
     */
    public synchronized void reduce()
    {
        while (this.product <= 0)
        {
            System.out.println("商品以空");
            try
            {
                this.wait();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "目前正在消费:" + --product);
        this.notifyAll();
    }
}

/**
 * 生产者
 */
class Product implements Runnable
{
    private Check check;

    public Product(Check check)
    {
        this.check = check;
    }


    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep(200);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.check.add();
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable
{
    private Check Check;

    public Consumer(Check Check)
    {
        this.Check = Check;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            this.Check.reduce();
        }
    }
}

线程正常结束

在这里插入图片描述

失忆๑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
thread.zip--狂神多线程+juc
03-18
此外，还有如ScheduledExecutorService用于定时任务，BlockingQueue用于生产者消费者模型，以及 Phaser 和 Exchanger 这些复杂场景下的并发工具。 总之，《狂神多线程+juc》资料包涵盖了Java并发编程的两大核心领域...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
JUC-7.生产者消费者案例-虚假唤醒
xbliu564的博客
03-11 421
1. 生产者和消费者案例 以下为生产者和消费者共享店员进行进货和售货的案例，生产者在库存已满时也不停进货，消费者在库存为0时也不停售货。 那么在实际生产中，就会造成生产者在库存已满时进货，造成数据丢失。消费者也会在不停的消费。 /** * 生产者和消费者案例 * @author xiaobin * @date 2018/3/11 */ public class TestProdu...
7.JUC-线程之间的通信
失忆๑的博客
10-12 140
一）线程的通信 1）使用Conditon接口描述可能会和锁相关的条件变量，这些变量在用法的上是一致的。 单个的lock可以多个的Conditon类对象关联，为了避免兼容问题，Conditon方法的名字和Object的名字不一致。 Conditon类的线程API 使用Conditon进行线程通信 package com.itguigu.demo1; import java.util.concu...
7、JUC--JUC线程高级_生产者消费者案例-虚假唤醒
weixin_34367845的博客
05-01 79
等待唤醒案例最经典的的就是：生产者消费者案例 首先定义一个店员进行买卖产品： //店员 class Clerk{ private int product =0; //进货 public synchronized void get(){ if(product >=10){ System.ou...
6、JUC:synchronized版生产者消费者问题，防止虚假唤醒问题
Garry
11-20 223
学习过程观看视频：[狂神说Java] https://www.bilibili.com/video/BV1B7411L7tE?p=2 欢迎大家支持噢，很良心的老师了！ 线程通信案例： package com.zjl; /** * Created by zjl * 2020/11/20 **/ /* * 1、线程之间的通信问题：生产者和消费者问题！ * 2、线程交替执行，A B 操作同一个变量 num = 0 * 3、A num+1 * 4、B num-1 * */ public class
JUC - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 568
JUC首先，再简单说一下并行、并发；进程、线程。
JUC-第七篇 : JUC线程 生产者消费者案例-虚假唤醒
程序员果果的博客
11-04 188
以下是一个案例，有一个店员，负责进货和卖货。进货生产，卖货消费。 当商品超过10件，生产等待，消费继续，当少于0件，消费等待，消费继续。一、演示的代码package co...
7.JUC线程高级-生产消费问题&虚假唤醒
Lambda
09-04 101
描述 生产消费问题在java多线程的学习中是经常遇到的问题 ，多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题。 实例说明 三个类：售货员Clerk，工厂Factory，消费者Consumer Factory和Consumer共享Clerk对象 1.普通情况 Clerk类： class Clerk{ //商品数量默认是0,volatile关键字保证内存可...
JUC线程高级(七) 生产者和消费者---虚假唤醒
轻描时光
06-02 1142
/* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor pro = new Productor(clerk); ...
java线程虚假唤醒_java多线程 生产者消费者案例-虚假唤醒
weixin_34234884的博客
02-26 63
packagecom.java.juc;importjava.util.concurrent.locks.Condition;importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;public classTestProductAndConsumer {public static vo...
tuling-juc-final.zip
05-23
项目"tuling-juc-final"很可能包含了多种使用volatile的场景，例如单例模式、信号量（例如使用`volatile`配合`wait()`和`notify()`实现线程间的协作），或者创建线程安全的计数器。 在深入研究这些代码示例时，我们...
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
Java.util.concurrent（JUC）是Java平台中处理高并发的核心工具包，它为开发者提供了丰富的并发组件和机制，使得在多线程环境下的编程变得更加高效和安全。本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类...
长虹ZLS58GI机芯JUC.820.00141998-v4主板图纸.pdf
01-09
6. 电源管理单元（PMU）：文件中提到PMU的设计，包括电源管理单元的架构设计和实现。这项技术对于电源管理的稳定性和可靠性非常重要。 7. 数字电源管理：文件中讨论了数字电源管理的重要性，包括数字电源管理单元的...
GEE数据集-高分辨率全球树冠高度地图（1 米）Meta 公司.pdf
07-17
绘制植被结构图对于了解全球碳循环以及监测基于自然的气候适应和减缓方法至关重要。通过对这些数据的重复测量，可以观察现有森林的砍伐或退化情况、森林的自然再生以及农林业等可持续农业实践的实施情况。高空间分辨率的树冠高度和树冠投影面积评估对于监测碳通量和评估基于树木的土地利用也很重要，因为森林结构在空间上可能高度异质，特别是在农林系统中。极高分辨率的卫星图像（地面采样距离小于一米）使提取树木层面的信息成为可能，同时还能进行大尺度监测。本文介绍了第一份同时为多个次国家辖区制作的高分辨率树冠高度图。具体来说，我们为加利福尼亚州和圣保罗州制作了非常高分辨率的树冠高度地图，与之前基于哨兵/GEDI 的全球树冠高度地图的十米（10 米）分辨率相比，分辨率有了显著提高。这些地图是通过在 2017 年至 2020 年的 Maxar 图像上训练的自监督模型中提取特征，并根据航空激光雷达地图训练密集预测解码器生成的。我们还引入了一个后处理步骤，使用在 GEDI 观测数据上训练的卷积网络。我们利用预留验证激光雷达数据以及与其他遥感地图和实地收集的数据进行比较，对所提出的地图进行了评估，发现我们的模型产生的平均绝对
Matlab下载安装、仿真实验方法.docx
07-17
通过以上步骤，你可以完成Matlab的安装、仿真实验的进行以及撰写详细的实验报告。这些步骤将帮助你建立一个清晰、系统的仿真实验流程。
遗传算法及其MATLAB实现
07-17
遗传算法（Genetic Algorithm, GA）最先是由美国Mic- hgan大学的John Holland于1975年提出的。遗传算法是 模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算 模型。它的思想源于生物遗传学和适者生存的自然规律， 是具有“生存+检测”的迭代过程的搜索算法。遗传算法 以一种群体中的所有个体为对象，并利用随机化技术指 导对一个被编码的参数空间进行高效搜索。其中，选择、 交叉和变异构成了遗传算法的遗传操作；参数编码、初始 群体的设定、适应度函数的设计、遗传操作设计、控制参 数设定等5个要素组成了遗传算法的核心内容。 下面是遗传算法的基本步骤以及基本程序流程简介附带有实现程序，可供参考与加深学习。
TI TMS570光盘HERCUle 安全MCU控制器
最新发布
07-17
TI TMS570光盘HERCUle 安全MCU控制器 开发板全套资料 百度网盘下载链接见附件，资源1.43G

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值