一生产者多消费者模型 / 多生产者一消费者模型

最新推荐文章于 2022-06-06 19:45:07 发布
最新推荐文章于 2022-06-06 19:45:07 发布
阅读量676 收藏 2
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43808717/article/details/115367069
版权

1. 异常问题（wait问题）

wait中断：在调用处立即中断并且释放锁，该线程转入等待队列。当收到持有同一把锁的线程notify通知后进入锁池队列，再次获得同步锁之后才会继续执行。这里的继续执行是从上次中断处继续向下执行。

package 多线程核心.生产者与消费者问题.一生产多消费操作栈假死与异常;
import java.util.ArrayList;

class MyService{
    private ArrayList list = new ArrayList();

    synchronized public void push() throws InterruptedException {
        if(list.size() == 1){		//改为while即可解决异常问题
            System.out.println(Thread.currentThread().getName()+" -> wait");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+" -> 生产");
        list.add(Math.random());
        System.out.println("size = " + list.size());
        this.notify();
    }

    synchronized public void pop() throws InterruptedException {
        if(list.size() == 0){		//改为while即可解决异常问题
            System.out.println(Thread.currentThread().getName()+" -> wait");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+" -> 消费");
        list.remove(0);
        System.out.println("size = " + list.size());
        this.notify();
    }
}

class P{

    private MyService myService;

    public P(MyService myService) {
        this.myService = myService;
    }

    public void pushService(){
        try{
            myService.push();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class C{

    private MyService myService;

    public C(MyService myService) {
        this.myService = myService;
    }

    public void popService(){
        try{
            myService.pop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadP extends Thread{
    private P p;

    public ThreadP(P p, String name) {
        super(name);
        this.p = p;
    }

    @Override
    public void run() {
        while(true)
            p.pushService();
    }
}
class ThreadC extends Thread{
    private C c;

    public ThreadC(C c, String name) {
        super(name);
        this.c = c;
    }

    @Override
    public void run() {
        while(true)
            c.popService();
    }
}

public class Demo {
    public static void main(String[] args) {
        MyService myService = new MyService();
        P p1 = new P(myService);

        C r1 = new C(myService);
        C r2 = new C(myService);
        C r3 = new C(myService);
        C r4 = new C(myService);
        C r5 = new C(myService);

        ThreadP p = new ThreadP(p1,"生产者");
        p.start();

        ThreadC c1 = new ThreadC(r1,"消费者-1");
        ThreadC c2 = new ThreadC(r2,"消费者-2");
        ThreadC c3 = new ThreadC(r3,"消费者-3");
        ThreadC c4 = new ThreadC(r4,"消费者-4");
        ThreadC c5 = new ThreadC(r5,"消费者-5");
        c1.start();
        c2.start();
        c3.start();
        c4.start();
        c5.start();

        try{
            Thread.sleep(5000);
            Thread[] arr = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
            Thread.currentThread().getThreadGroup().enumerate(arr);

            for(int i = 0;i < arr.length;i++){
                System.out.println(arr[i].getName() + " -> " + arr[i].getState());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

  1. 分析：出现异常是因为ArratList删除元素越界了，首先要了解wait中断机制。wait中断是在此处立即中断并且释放锁，转入等待队列。当收到notify通知后进入锁池队列，再次获得同步锁之后才会继续执行。这里的继续执行是从上次中断处继续向下执行。当多个线程都wait之后，突然有个wait线程中断恢复继续向下执行，由于并没有什么条件判断或者限制导致size = 0时依旧将第1个(下标为0)的元素移除，此时ArrayList中已经为空，所以导致数组越界。

  2. 由于中断恢复回来之后，中断前的状态 和 中断恢复后的状态是无法预测的，谁也不知道恢复后是个什么样子，中断时size=0才中断，中断恢复后并不知道此时size是否依旧为0? 所以在恢复后依旧需要继续判断最初的中断条件是否成立。

  3. 解决方法：将if 改为 while。这样即使回来之后size = 0依旧会进行一次判断，如果size == 0继续中断，不为0才能移除ArrayList中的元素。

2. 假死问题（notify问题）

notify唤醒：随机唤醒一个持有同一把锁的wait线程，这个线程是随机无法指定的。

notifyAll唤醒：唤醒所有持有同一把锁的wait线程。

将上面代码中的if 改为 while后依旧存在问题，这里存在 “假死”。

import java.util.ArrayList;

class MyService{
    private ArrayList list = new ArrayList();

    synchronized public void push() throws InterruptedException {
        while(list.size() == 1){
            System.out.println(Thread.currentThread().getName()+" -> wait");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+" -> 生产");
        list.add(Math.random());
        System.out.println("size = " + list.size());
        this.notify();			//改为notifyAll();   解决假死
    }

    synchronized public void pop() throws InterruptedException {
        while(list.size() == 0){
            System.out.println(Thread.currentThread().getName()+" -> wait");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+" -> 消费");
        list.remove(0);
        System.out.println("size = " + list.size());
        this.notify();			//改为notifyAll();   解决假死
    }
}

class P{

    private MyService myService;

    public P(MyService myService) {
        this.myService = myService;
    }

    public void pushService(){
        try{
            myService.push();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class C{

    private MyService myService;

    public C(MyService myService) {
        this.myService = myService;
    }

    public void popService(){
        try{
            myService.pop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadP extends Thread{
    private P p;

    public ThreadP(P p, String name) {
        super(name);
        this.p = p;
    }

    @Override
    public void run() {
        while(true)
            p.pushService();
    }
}
class ThreadC extends Thread{
    private C c;

    public ThreadC(C c, String name) {
        super(name);
        this.c = c;
    }

    @Override
    public void run() {
        while(true)
            c.popService();
    }
}

public class Demo {
    public static void main(String[] args) {
        MyService myService = new MyService();
        P p1 = new P(myService);

        C r1 = new C(myService);
        C r2 = new C(myService);
        C r3 = new C(myService);
        C r4 = new C(myService);
        C r5 = new C(myService);

        ThreadP p = new ThreadP(p1,"生产者");
        p.start();

        ThreadC c1 = new ThreadC(r1,"消费者-1");
        ThreadC c2 = new ThreadC(r2,"消费者-2");
        ThreadC c3 = new ThreadC(r3,"消费者-3");
        ThreadC c4 = new ThreadC(r4,"消费者-4");
        ThreadC c5 = new ThreadC(r5,"消费者-5");
        c1.start();
        c2.start();
        c3.start();
        c4.start();
        c5.start();

        try{
            Thread.sleep(5000);
            Thread[] arr = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
            Thread.currentThread().getThreadGroup().enumerate(arr);

            for(int i = 0;i < arr.length;i++){
                System.out.println(arr[i].getName() + " -> " + arr[i].getState());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

1. 假死原因分析

  1. 生产者 首先获得锁生产一个产品，notify指令失效(没有同锁wait线程)

  2. 生产者再次快速获得锁由于生产的产品还未消耗 生产者进入wait状态

  3. 此时消费者2获得锁将产品进行了消费(注意：这里消费者1已经诞生但是并没有获得锁，在锁池队列等待)，notify唤醒唯一等待的生产者线程

  4. 消费者2继续获得锁，此时已经没有产品消费了， 消费者2进入wait状态

  5. 消费者3拿到锁，此时已经没有产品消费了， 消费者3进入wait状态

  6. 生产者 获得锁生产一个产品，现在等待的有消费者2 消费者3，notify唤醒哪一个是不确定的。根据图片继续分析才知道

  7. 生产者 再次获得锁，产品没有消耗， 生产者进入wait状态

  8. 消费者2获得锁，进行了消费( 这里说明第5步生产者唤醒了消费者2)，此时wait的线程有，消费者3和生产者，notify唤醒哪个不知道继续向下分析

  9. 消费者2再次获锁，没有产品消耗， 消费者2进入wait状态

  10. 消费者3获锁(这里说明第7步 消费者2唤醒了消费者3)，没有产品消耗， 消费者3进入wait状态

  11. 消费者4获锁，没有产品消耗， 消费者4进入wait状态

  12. 此时沉默许久的消费者1首次获得锁， 没有产品消耗， 消费者1进入wait状态

  13. 消费者5获锁，没有产品消耗， 消费者5进入wait状态

  14. 到此生产者在第6步wait之后再也没起来过，后续由于第7步的消费者2错误唤醒了同样是消费者的线程3导致一蹶不振，至此线程全线wait导致假死。

假死的原因根据上面的分析很容易得出，由于notify随机唤醒，连续唤醒同类(同样是消费者)导致假死

2. 假死解决方案

将所有的notify改为nofityAll()，这样让每个线程都将所有的线程全部唤醒，这样就解决了随机唤醒并且唤醒同类的问题。因为总能保证生产者一直处于锁池队列争抢同步锁进入Runnable状态。



一生产多消费模型 和 多生产一消费模型是一样的，一样需要注意异常和假死问题。

在这里插入图片描述

Splaying
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华南理工大学操作系统实验：生产者消费者问题
12-15
参考教材中的生产者消费者算法，创建5个进程，其中两个进程为生产者进程，3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母，另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，仿照的实例程序，分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。 可选的实验：在上面实验的基础上实现部分消费者有选择地消费某些产品。例如一个消费者只消费小写字符，一个消费者只消费大写字母，而另一个消费者则无选择地消费任何产品。消费者要消费的产品没有时，消费者进程被阻塞。注意缓冲的管理。
C多线程：一生产者与多消费者
weixin_43632162的博客
11-19 1109
C多线程：一生产者与多消费者 /** 本例程是创建一个线程作为生产者，三个线程作为消费者 要求： a)为解决供多于求的情况，生产者一次只能生产一个，并等待消费者获取再生产下一个 b)消费者们防止资源竞争，不能同时获取一个数，即前一个消费者获取了一个数，下一个消费者要等待下一个数的产生 才可以获取 实现：加锁 + 信号信号量 + 条件判断 1)两个全局变量 num 和 flag，解决问题a)关键在于生产者每生产一个数，num加一，唯有当flag == num时，生 产者才可以生产下一个；消
Kafka —— java实现一生产者多消费者实例
DGH2430284817的博客
06-16 6196
架构图：（网图，很通俗易懂了，就不自己画了，这里实现的是一个Producer 两个Consumer） 前提：已经开启zookeeper 和kafka ，具体可参考博客https://blog.csdn.net/DGH2430284817/article/details/90483089 步骤： 1,：设置kafka 分区为2 ： 修改kafk...
如何在rabbitmq中实现一个生产者，多个消费者，多个消费者都能收到同一条消息
热门推荐
weixin_43757027的博客
05-06 1万+
如何在rabbitmq中实现一个生产者，多个消费者，多个消费者都能收到同一条消息 场景：用户登录，邀请其它用户进行视频会议，收到邀请的用户进入会议 rabbitmq实现思路： 选型：发布订阅模式（Publish/Subscribe） 一个生产者，多个消费者，每一个消费者都有自己的一个队列，生产者没有将消息直接发送到队列，而是发送到了交换机，每个队列绑定交换机，生产者发送的消息经过交换机，到达队列，实现一个消息被多个消费者获取的目的。 这种情况下，我们有四种交换机可供选择，分别是： Direct
生产者消费者问题
m0_61705102的博客
05-02 520
文章目录问题概述单生产者单消费者队列思路概述代码多生产者多消费者队列(这里以3个生产者3个消费者为例)思路概述代码 问题概述 生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者线程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者线程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。 单生产者单消费者队列 思路概述 使用队列的方式来存储产品，创建
Java多线程 生产者消费者模型实例详解
08-25
主要介绍了Java多线程 生产者消费者模型实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Queue 实现生产者消费者模型(实例讲解)
12-25
3、还有一种是优先级队列级别越低越先出来。 class Queue.PriorityQueue(maxsize) 此包中的常用方法(q = Queue.Queue()): q.qsize() 返回队列的大小 q.empty() 如果队列为空，返回True,反之False q.full
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
主要介绍了Java多线程 BlockingQueue实现生产者消费者模型详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
wpf窗体多线程实现生产者消费者模型
10-31
wpf窗体多线程实现生产者消费者模型（利用信号量），工作线程利用回调函数改变窗体线程的控件。
基于条件变量实现的生产者消费者模型
02-18
基于Linux C++的条件变量实现的生产者消费者模型，旨在进一步帮助读者理解条件变量的使用。
单生产者 多消费者模型
BJUT_bluecat的博客
05-08 1610
问题出处：https://blog.csdn.net/u010236550/article/details/12372319 生产者消费者问题：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但...
生产者-消费者问题（三个进程P1、P2、P3互斥使用一个包含N个单元的缓冲区）
super_iron_man的博客
10-07 9276
1.问题描述 2.问题分析 同步问题： （1）包含N个缓冲区单元，有空位置时才能写，即P1、P2、P3共享缓冲区空位，设置同步信号量empty； （2）存在奇数时才能读出奇数，P1、P2共享奇数缓冲区，设置同步信号量odd； （3）存在偶数时才能读出偶数，P1、P3共享偶数缓冲区，设置同步信号量even。 互斥问题： 三个进程彼此之间互斥的访问缓冲区，设置互斥信号量mutex。 3.注意事项 1.不要误认为是读者-写者问题，注意这里P2、P3之间也是互斥的，而读者之间的访问可以同时，这里只是单生产者多消费
MQ 入门【2】--一个生产者对应多个消费者（轮询机制）
u012045045的博客
07-02 3714
（1）连接 package com.utils; import java.io.IOException; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; public class ConnectionUtils { public static Connection...
认识生产者消费者问题
Cecilia3333的博客
04-11 296
生产者消费者问题是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”，在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者在缓冲区中消耗这些数据。该问题的关键是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据。要解决这个问题，就必须让生产者在缓冲区满时休眠，等到下次消费...
生产者与消费者问题算法 C++（一对多）
weixin_52305468的博客
06-06 2622
通过生产者与消费者的问题算法，加深对信号量机制的理解和了解信号量的使用。1.问题描述一组生产者向多组消费者提供消息，它们共享一个有界缓冲池，生产者向其中投放消息，消费者从中取得消息。假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将消息送入缓冲池,只要缓冲池未空，消费者可从缓冲池取走一个消息。2.功能要求根据进程同步机制，编写一个解决上述问题的程序，可显示缓冲池状态、放数据、取数据等过程。 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Boun
生产者――消费者问题算法的实现
weixin_52502839的博客
06-06 714
生产者――消费者问题算法的实现实验报告！！
经典同步问题一——生产者和消费者问题
yilia学习小园
04-16 573
不懂得结构型信号量的小伙伴可参考下面博文，之后再阅读本博文，更易于理解 https://blog.csdn.net/weixin_36465540/article/details/105559848 生产者和消费者问题 问题描述 一个或多个生产者产生数据并放在缓冲区中，每次一个。 一个或多个消费者从缓冲区取数据项并消费，每次一个。 条件： 1 在任意时间只能一个生产者或消费者访问缓冲区——互斥 2...
c++多线程之单个生产者：多个消费者
so
05-17 3775
const int NUM = 50; bool ready = false; struct DATA { int num; }; struct node { DATA data[NUM]; // 定义一个大小为10的缓冲区 int tail; int front; int count; //记录队列长度 condition_variable is_not_full; condi...
生产者/消费者模型与客户端/服务器的区别
最新发布
05-15
生产者/消费者模型是一种并发编程的模型，用于解决多线程间数据共享和同步的问题。在这个模型中，生产者负责生成数据并将它们放入缓冲区，消费者从缓冲区中取出数据并进行处理。这个模型的目的是协调生产者和消费者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值