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

最新推荐文章于 2022-10-20 15:34:16 发布
最新推荐文章于 2022-10-20 15:34:16 发布
阅读量748 收藏 4
点赞数 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菜鸡找工作真难，一次一次降低自己的标准，唉！愿：心所想，有所成，加油各位！！！冲！！！

想成为大牛的渣渣
关注
专栏目录
循环队列 - 生产者与消费者模型
xiongli880612的专栏
02-22 2186
循环队列可以实现一个生产者与一个消费者模型， 不使用锁。   循环队列：size=10 生产者线程：不停地把从0递增的整数push到队列(尾部不存储，也就是最大存9个数)，满了就等1s。 消费者线程：每3s从队列pop一个元素。 [xiongli@localhost data_struct]$ ./a.out             push 0 at data[0] push 1
Java"设计模式"——生产消费者模式及三种实现方式
xiaoaxiao
10-13 1855
Java设计模式——生产消费者模式 一、生产消费者模式原理   1、生产消费者模式主要是将生产者与消费者解耦，通过一个容器来解决生产者和消费者的强耦合问题，生产者消费者彼此之间不直接通讯，而是通过阻塞队列来进行通讯。   2、生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者也不找生产者要数据，而是直接从阻塞队列中取得，阻塞队列相当于一个缓冲区，平衡了生产者与消费者的处理能力，使得生...
一篇给你分析懂生产者与消费者问题为什么使用while不使用if（JUC）
qq_45875887的博客
05-29 501
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 4658
永远在循环（loop）里调用 wait 和 notify，不是在 If 语句 现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用，下一个一定要记住的问题就是，你应该永远在while循环，而不是if语句中调用wait。因为线程是在某些条件下等待的——在我们的例子里，即“如果缓冲区队列是满的话，那么生产者线程应该等待”，你可能直觉就会写一个if语句。但i
生产者/消费者模式为什么wait()要用while做判断而不是if做判断（清晰可理解）
jdsydwr的博客
02-14 1484
生产者/消费者模式为什么wait()要用while做判断而不是if做判断（清晰可理解）
为什么生产者消费者中模式中要用while作临界判断？
qq_37430539的博客
08-21 1755
关于生产者模式，想必大家也非常了解了，其中java实现的一个简易模型：生产者在一个固定容量的容器中加入元素，通知消费者消费，消费者消费后通知生产者生产 ​ 当生产的时候需要判断容器中是否已经满，为什么这个判断需要用while而不能用if呢，例如下面代码中第7行 public class MyContainer1<T> { final private LinkedList<T&g...
生产者消费者循环条件判断用if还是while的问题
tomorrow_shoe的博客
08-05 1288
//生产者 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&Python实现
catch_dreamer的博客
11-02 462
1、概述 生产者消费者设计模式是一个典型的线程同步问题，其主要描述的场景是一个模块生产数据或者产生数据，另一个模块用于读取或者说处理数据，一般来讲，还会有一个缓冲区，用来保存生产模块产生出来的数据。 其相关的模型如下所示： 其中缓冲区的作用是主要有以下几个： 解耦合：如上图，如果没有缓冲区，生产者将直接调用消费者中的相关方法，那么生产者模块将会对消费者模块产生依赖，也就是耦合。 支持并发：由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有执行完成之前，生产者只能一直处于等待状态。如果消费者处理数据
Python-多线程及生产者与消费者
新阿巴阿巴
01-13 1982
一. 前置知识 1. 队列基础 如果不指定队列是什么，请自行查阅 在Python中，队列是最常用的线程间的通信方法，因为它是线程安全的 from queue import Queue # 创建队列 # -- 限制队中最多有 maxsize 个元素 # -- 如果省略参数，默认元素个数无限制 q = Queue(100) q1 = Queue() # 元素入队 q.put(1) q.put(True) q.put('abc') # 队列的大小 print(q.qsize()) # 判断队满
并发编程专题-5：生产者和消费者模式
你好，开发者
02-17 485
所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。 在实现生产者消费者问题时，可以采用三种方式： 使用 Object 的 wa...
java多线程下为什么建议使用while不使用if
GX的博客
05-03 3021
多线程的情况下，单个生产者和单个消费者用if判断是否await不会出错；当有多个消费者的时候，还使用if判断是否await就会产生问题，这是因为一个生产者消费者模型的任务队列，一个消费者一次放入多个任务，然后用notifyAll通知消费者，但是并非所有被唤醒的消费者都能取到一个任务，那么队列被读空了之后的消费者肯定得继续await。如果你用if来判断，这个消费者第二次被notify的时候就不会再次...
生产者消费者模式
Meiko记录
06-28 1407
生产者消费者模型为什么要使用生产者和消费者模式在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，所以便有了生产者和消费者模式。什么是生产者消费者模式生产者消费...
逐步详细分析Java生产者-消费者问题，为什么使用 while 而不用 if ？
她的坏机器人
08-10 763
内容 1、存钱取钱（逐步分析生产者消费者问题） 2、使用 wait-notifyAll 实现生产者-消费者 3、使用 LinkedBlockingQueue 实现生产者-消费者 存钱-取钱 1、一个人存钱，一个人取钱：在卡中没钱的时候存钱，有钱的时候取钱，交替执行 flag为true时：只能取钱，存钱会被阻塞 flag为false时：只能存钱，取钱会被阻塞 public class BankCard { private double money; // true:只能取.
生产者-消费者问题
codefan※的博客
10-20 376
这里就有很大的问题，还是那个道理，有P必V，建议就是做出一个P，先找在何处V，再去进行下一个PV的操作，这样就不容易出现缺漏。上述解答会产生死锁：若桶都被consumer拿走，但是缸中无水，此时producer也无法打水，程序死锁。解决方法：1. PV连续出现，不可能死锁；2.多个P死锁，则尝试调整P操作的顺序。在该类问题中死锁的情况基本只有请求和保持。（多加了一个判断货架是否有产品）
【重点】生产者消费者（设置flag标记：最佳实践）多生产者多消费者（把if换成while）
闲着没事_玩玩JAVA的专栏
10-20 895
生产者消费者问题 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 678
0、前言 生产者消费者模式：一个producer线程生产，一个consumer消耗，当producer过快的时候实行丢帧操作，当consumer过快时实行超时机制的等待(等待不到就返回空) 通俗的话讲：当"面包"生产过剩的时候，就倒掉仓库中的部分面包(俗称:资本主义倒牛奶),当"面包"消耗的过快的时候，就让顾客等着,如果顾客没有耐心等到(超时机制)，就让他回去 1、实现自定义事件(事件同步) #pragma once #include <windows.h> ...
生产者消费者模式中，等待条件判断 if 和 while 的区别
hqq_123的博客
08-04 780
说明： 有三个生产者，三个消费者（各三个线程代表）。当产品数为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 843
#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 771
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;//队头指针，读指
Shell脚本生产者消费者
最新发布
06-09
在 Shell 脚本中，可以使用循环和条件语句来实现生产者消费者模型。具体来说，生产者和消费者可以分别使用两个不同的函数来实现，这两个函数可以分别在两个不同的进程中执行。 生产者函数的主要作用是生成数据并将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

想成为大牛的渣渣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值