生产者消费者模式为什么不用if语句而用while循环

最新推荐文章于 2022-10-20 15:34:16 发布
最新推荐文章于 2022-10-20 15:34:16 发布
阅读量721 收藏 3
点赞数 1
分类专栏： 笔记 JavaSE 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45702658/article/details/120709336
版权

一、生产者消费者模式（只有两个线程一个是生产者线程一个是消费者线程）

重点！！！！！！！看这篇博客的时候首先要描述一下wait（）方法的等待机制，当当先线程被wait之后会释放锁，当这个线程被唤醒的时候会继续从wait方法后面的代码继续执行。这个点也是这篇文章的点睛之笔，重中之重。也是为什么不用if用while的原因。

小声bb：我也是翻阅好多文章才知道线程阻塞，被唤醒之后竟然会接着执行线程wait方法后面的代码。我原来竟然一直傻逼的认为这个线程被阻塞之后会重新执行。菜鸟就是我我就是彩笔。

首先看一下只有一个生产者和线程一个消费者线程的情况，这个时候使用if(多个生产者和消费者线程的时候一定要使用while，下面会接着描述)不会出现数据错误，因为只有两个线程调用this.notifyAll()的时候只会唤醒所有的线程，但是这个时候只有一个等待线程。代码如下：

package com.aa.生产者消费者模式;

public class A {

    public static void main(String[] args) {
        Data data = new Data();

        //生产者线程A1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者A1").start();

        //消费者线程B1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者B1").start();

    }


}

//这是是共享区域data，里面只有一个属性num
class Data{
    private int num=0;

    //生产者对 num++
    public synchronized void increment() throws InterruptedException {
        
        //我是故意用if的，在这里不会出错，因为只有两个线程，被唤醒的只能是消费者线程，对num--
        if(num!=0){
            this.wait();  //此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他线程
        this.notifyAll();
    }

    //消费者对 num--
    public synchronized void decrement() throws InterruptedException {

        //我是故意用if的，在这里不会出错，因为只有两个线程，被唤醒的只能是生产者线程
        if (num==0){
            this.wait();//此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }

        num--;

        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他等待的线程
        this.notifyAll();
    }
}

这个是程序正常运行的结果：
在这里插入图片描述

二、然后给大家演示一下开始四个线程，两个消费者线程两个生产者线程

此时有生产者A1，生产者A2，消费者B1，消费者B2

package com.aa.生产者消费者模式;

public class A {

    public static void main(String[] args) {
        Data data = new Data();

        //生产者线程A1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者A1").start();

        //消费者线程B1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者B1").start();

          new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者A2").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者B2").start();

    }


}

//这是是共享区域data，里面只有一个属性num
class Data{
    private int num=0;

    //生产者对 num++
    public synchronized void increment() throws InterruptedException {


        if(num!=0){
            this.wait();  //此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他线程
        this.notifyAll();
    }

    //消费者对 num--
    public synchronized void decrement() throws InterruptedException {

        if (num==0){
            this.wait();//此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }

        num--;

        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他等待的线程
        this.notifyAll();
    }
}

然后给大家看一下运行效果：
在这里插入图片描述前面运行还算正常，后面就不正常了。而且会出现死循环。程序一直运行。主要就是因为使用了if语句当线程阻塞后，被挂起，当其他线程使用notifyAll（）之后，假如这个线程被执行了，这个被挂起的线程会接着执行wait（）方法后面的代码，对num++或者num--，但是如果使用while替代if之后他会一直判断当前条件满不满足不满足接着被wait（）直至不满足while的判断语句时之后才会继续执行，而if是直接执行不会再次进行判断。

三、正确的生产者消费者模式

正确的生产者消费者代码如下：

package com.aa.生产者消费者模式;

public class A {

    public static void main(String[] args) {
        Data data = new Data();

        //生产者线程A1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者A1").start();

        //消费者线程B1
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者B1").start();

          new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者A2").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者B2").start();

    }


}

//这是是共享区域data，里面只有一个属性num
class Data{
    private int num=0;

    //生产者对 num++
    public synchronized void increment() throws InterruptedException {


        while(num!=0){
            this.wait();  //此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他线程
        this.notifyAll();
    }

    //消费者对 num--
    public synchronized void decrement() throws InterruptedException {

        while (num==0){
            this.wait();//此时线程阻塞，让线程被唤醒之后会重新继续执行后续代码，这也是为什么不用if用while的原因
        }

        num--;

        System.out.println(Thread.currentThread().getName()+"==="+num);
        //唤醒其他等待的线程
        this.notifyAll();
    }
}

程序运行之后的效果如下：
在这里插入图片描述
我刚开始也是不理解while和if在生产者和消费者之间的区别，我也是在经历校招准备面试某公司很长时间失败之后，才偶然发现的。于是奋笔疾书给大家分享一下，希望能够帮助大家顺利找到心仪的公司，小声bb菜鸡找工作真难，一次一次降低自己的标准，唉！愿：心所想，有所成，加油各位！！！冲！！！

想成为大牛的渣渣
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
循环队列 - 生产者与消费者模型
xiongli880612的专栏
02-22 2172
循环队列可以实现一个生产者与一个消费者模型， 不使用锁。   循环队列：size=10 生产者线程：不停地把从0递增的整数push到队列(尾部不存储，也就是最大存9个数)，满了就等1s。 消费者线程：每3s从队列pop一个元素。 [xiongli@localhost data_struct]$ ./a.out             push 0 at data[0] push 1
一篇给你分析懂生产者与消费者问题为什么使用while不使用if（JUC）
qq_45875887的博客
05-29 476
JAVA代码示例 package com.juc.producerandconsumer; public class Syn1 { public static void main(String[] args) { Data data = new Data(); new Thread(() -> { for (int i = 0; i < 5; i++) { data.producer();
生产者消费者模式中条件判断是使用while而不是if
u011863767的博客
03-02 4644
永远在循环（loop）里调用 wait 和 notify，不是在 If 语句 现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用，下一个一定要记住的问题就是，你应该永远在while循环，而不是if语句中调用wait。因为线程是在某些条件下等待的——在我们的例子里，即“如果缓冲区队列是满的话，那么生产者线程应该等待”，你可能直觉就会写一个if语句。但i
生产者/消费者模式为什么wait()要用while做判断而不是if做判断（清晰可理解）
jdsydwr的博客
02-14 1471
生产者/消费者模式为什么wait()要用while做判断而不是if做判断（清晰可理解）
为什么生产者消费者中模式中要用while作临界判断？
qq_37430539的博客
08-21 1715
关于生产者模式，想必大家也非常了解了，其中java实现的一个简易模型：生产者在一个固定容量的容器中加入元素，通知消费者消费，消费者消费后通知生产者生产 ​ 当生产的时候需要判断容器中是否已经满，为什么这个判断需要用while而不能用if呢，例如下面代码中第7行 public class MyContainer1<T> { final private LinkedList<T&g...
java多线程下为什么建议使用while不使用if
GX的博客
05-03 3008
多线程的情况下，单个生产者和单个消费者用if判断是否await不会出错；当有多个消费者的时候，还使用if判断是否await就会产生问题，这是因为一个生产者消费者模型的任务队列，一个消费者一次放入多个任务，然后用notifyAll通知消费者，但是并非所有被唤醒的消费者都能取到一个任务，那么队列被读空了之后的消费者肯定得继续await。如果你用if来判断，这个消费者第二次被notify的时候就不会再次...
生产者消费者模式
Meiko记录
06-28 1404
生产者消费者模型为什么要使用生产者和消费者模式在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，所以便有了生产者和消费者模式。什么是生产者消费者模式生产者消费...
逐步详细分析Java生产者-消费者问题，为什么使用 while 而不用 if ？
她的坏机器人
08-10 736
内容 1、存钱取钱（逐步分析生产者消费者问题） 2、使用 wait-notifyAll 实现生产者-消费者 3、使用 LinkedBlockingQueue 实现生产者-消费者 存钱-取钱 1、一个人存钱，一个人取钱：在卡中没钱的时候存钱，有钱的时候取钱，交替执行 flag为true时：只能取钱，存钱会被阻塞 flag为false时：只能存钱，取钱会被阻塞 public class BankCard { private double money; // true:只能取.
生产者-消费者问题
codefan※的博客
10-20 359
这里就有很大的问题，还是那个道理，有P必V，建议就是做出一个P，先找在何处V，再去进行下一个PV的操作，这样就不容易出现缺漏。上述解答会产生死锁：若桶都被consumer拿走，但是缸中无水，此时producer也无法打水，程序死锁。解决方法：1. PV连续出现，不可能死锁；2.多个P死锁，则尝试调整P操作的顺序。在该类问题中死锁的情况基本只有请求和保持。（多加了一个判断货架是否有产品）
【重点】生产者消费者（设置flag标记：最佳实践）多生产者多消费者（把if换成while）
闲着没事_玩玩JAVA的专栏
10-20 876
生产者消费者问题 package com.xiaozhi.threadinformation; /* * 生产者消费者 */ public class Test3 { public static void main(String[] args) { Resource resource=new Resource(); Producer producer=new Producer
基于生产者、消费者的循环队列
qq_15821883的博客
11-17 629
0、前言 生产者消费者模式：一个producer线程生产，一个consumer消耗，当producer过快的时候实行丢帧操作，当consumer过快时实行超时机制的等待(等待不到就返回空) 通俗的话讲：当"面包"生产过剩的时候，就倒掉仓库中的部分面包(俗称:资本主义倒牛奶),当"面包"消耗的过快的时候，就让顾客等着,如果顾客没有耐心等到(超时机制)，就让他回去 1、实现自定义事件(事件同步) #pragma once #include <windows.h> ...
生产者消费者模式中，等待条件判断 if 和 while 的区别
hqq_123的博客
08-04 771
说明： 有三个生产者，三个消费者（各三个线程代表）。当产品数为0时开始生产产品，生产一个后通知消费者消耗产品，之后又生产。所以一直在0和1中徘徊，正确输出为1和0交替出现/ 一.if 控制等待条件，代码和结果如下 执行代码：Test package com.hz.wjsc.mservice.syntheticwarfare.test.thread.produce; public class Test { public static void main(String[] args) {
生产者消费者模型，循环队列实现
张树杰的博客
07-14 836
#define QUEUE_LEN 1024 typedef struct ObjectListCell { int size; void* value; } ObjectListCell; typedef struct ObjectList { ObjectListCell *queue; int head; int tail; int len; int
操作系统共享内存消费者生产者循环队列
qq_43312665的博客
10-16 750
shmdata.h #ifndef _SHMDATA_H_HEADER #define _SHMDATA_H_HEADER #include "stdio.h" #include "string.h" #include "stdbool.h" #define TEXT_LEN 10 #define MAX_SIZE 5 typedef struct queue {//循环队列 char buf[TEXT_LEN * MAX_SIZE];//字符串数组 int front;//队头指针，读指
生产者消费者循环条件判断用if还是while的问题
tomorrow_shoe的博客
08-05 1268
//生产者 public class p { private String lock; public p(String lock) { this.lock = lock; } public void setValue() { try { // 生产者 synchronized (lock) { System.out.println(Thread.curre...
java多线程并发环境下为什么使用while而不用if
黄嚯嚯
06-30 1459
目录前言一 . 使用if所引发的问题1.1 虚假唤醒 1.2 虚假唤醒代码示例 1.3 解决虚假唤醒二 . 为什么用while就能解决问题结论再开始本文之前 , 先给大家看一张图 , 这是Object.wait()的源码介绍 , 翻译过来内容如下我们在使用线程时，进行条件判断时，往往会先考虑使用if进行判断,在线程进行等待时就会出现不确定的结果。先来看看两个线程下的操作。首先创建一个模拟业务类, 也是一个经典案例 "生产者&消费者" 然后分别创建补货/售货两个线程 , 用来模拟后续的动作 接下来创
linux生产者消费者进程,Linux生产者与消费者的问题实现
weixin_33048721的博客
04-28 305
#include#define BUFFER_SIZE 10 /* 公用环形缓冲区的大小 */#define PRODUCER_NUM 5 /* 生产者进程的个数 */#define CONSUMER_NUM 5 /* 消费者进程的个数 */#define RWRWRW S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH /* 设定创建的文件的访问权限为...
【C++】多线程(链式、循环队列)实现生产者消费者模式
qq_45829112的博客
03-22 6280
链式队列和双循环队列实现多线程的生产者和消费者模式
生产者与消费者
weixin_45794641的博客
02-18 3990
生产者与消费者，虚假唤醒
Shell脚本生产者消费者
最新发布
06-09
好的，我可以为您讲解 Shell 脚本中的生产者消费者模型。 在 Shell 脚本中，可以使用循环和条件语句来实现生产者消费者模型。具体来说，生产者和消费者可以分别使用两个不同的函数来实现，这两个函数可以分别在两个不同的进程中执行。 生产者函数的主要作用是生成数据并将其存储到共享缓冲区中，而消费者函数则从共享缓冲区中获取数据并进行相应的处理。在这个过程中，需要使用互斥锁和信号量来确保数据的正确性和一致性。 下面是一个简单的 Shell 脚本生产者消费者模型的示例代码： ```bash #!/bin/bash # 定义共享缓冲区 BUFFER_SIZE=5 buffer=() # 定义互斥锁和信号量 mutex=1 empty=${BUFFER_SIZE} full=0 # 定义生产者函数 producer() { while true; do # 申请 empty 信号量 if [[ ${empty} -gt 0 ]]; then # 申请互斥锁 if [[ ${mutex} -eq 1 ]]; then # 生产数据并存储到共享缓冲区 item=$(date +%s) buffer+=(${item}) echo "生产者生产了数据：${item}" # 释放互斥锁 mutex=0 # 更新 empty 和 full 信号量 empty=$((${empty}-1)) full=$((${full}+1)) fi fi # 延时一定时间 sleep 1 done } # 定义消费者函数 consumer() { while true; do # 申请 full 信号量 if [[ ${full} -gt 0 ]]; then # 申请互斥锁 if [[ ${mutex} -eq 1 ]]; then # 获取共享缓冲区中的数据并进行处理 item=${buffer[0]} buffer=("${buffer[@]:1}") echo "消费者消费了数据：${item}" # 释放互斥锁 mutex=0 # 更新 empty 和 full 信号量 empty=$((${empty}+1)) full=$((${full}-1)) fi fi # 延时一定时间 sleep 1 done } # 启动生产者和消费者进程 producer & consumer & ``` 在这个示例代码中，我们定义了一个大小为 5 的共享缓冲区，以及一个互斥锁和两个信号量。生产者函数和消费者函数分别使用了无限循环来不断地执行生产和消费操作。其中，在生产者函数中，我们使用了 `date +%s` 命令来生成一个时间戳作为数据，并将其存储到共享缓冲区中；在消费者函数中，我们从共享缓冲区中获取了第一个数据，并将其从缓冲区中删除。 需要注意的是，这个示例代码只是一个简单的演示，实际上在真实的生产环境中，需要考虑更多的细节和问题，例如如何处理缓冲区溢出、如何在生产者和消费者之间进行数据同步等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

想成为大牛的渣渣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值