java并发编程系列:生产者-消费者模式

Java并发编程(六)——三种方式实现生产者消费者模式 生产者消费者模式介绍 生产者消费者模式是程序设计中非常常见的一种设计模式,被广泛运用在解耦、消息队列等场景。在现实世界中,我们把生产商品的一方称为生产者,把消费商品的一方称为消费者,有时生产者的生产速度特别快,但消费者的消费速度跟不上,俗称“产能过剩”,又或是多个生产者对应多个消费者时,大家可能会手忙脚乱。如何才能让大家更好地配合呢?这时在生产者和消费者之间就需要一个中介来进行调度,于是便诞生了生产者消费者模式。 使用生产者消费者模式通常需要在两者之间增加一个阻塞队列作为媒介,有了媒介之后就相当于有了一个 阅读详情

目光从厕所转到饭馆,一个饭馆里通常都有好多厨师以及好多服务员,这里我们把厨师称为生产者,把服务员称为消费者,厨师和服务员是不直接打交道的,而是在厨师做好菜之后放到窗口,服务员从窗口直接把菜端走给客人就好了,这样会极大的提升工作效率,因为省去了生产者和消费者之间的沟通成本。从java的角度看这个事情,每一个厨师就相当于一个生产者线程,每一个服务员都相当于一个消费者线程,而放菜的窗口就相当于一个缓冲队列,生产者线程不断把生产好的东西放到缓冲队列里,消费者线程不断从缓冲队列里取东西,画个图就像是这样:

现实中放菜的窗口能放的菜数量是有限的,我们假设这个窗口只能放5个菜。那么厨师在做完菜之后需要看一下窗口是不是满了,如果窗口已经满了的话,就在一旁抽根烟等待,直到有服务员来取菜的时候通知一下厨师窗口有了空闲,可以放菜了,这时厨师再把自己做的菜放到窗口上去炒下一个菜。从服务员的角度来说,如果窗口是空的,那么也去一旁抽根烟等待,直到有厨师把菜做好了放到窗口上,并且通知他们一下,然后再把菜端走。
我们先用java抽象一下菜:

public class Food {
    private static int counter = 0;

    private int i;  //代表生产的第几个菜

    public Food() {
        i = ++counter;
    }

    @Override
    public String toString() {
        return "第" + i + "个菜";
    }
}

每次创建Food对象,字段i的值都会加1,代表这是创建的第几道菜。

为了故事的顺利进行,我们首先定义一个工具类:

class SleepUtil {

    private static Random random = new Random();
    
    public static void randomSleep() {
        try {
            Thread.sleep(random.nextInt(1000));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

SleepUtil的静态方法randomSleep代表当前线程随机休眠一秒内的时间。

然后我们再用java定义一下厨师:

public class Cook extends Thread {

    private Queue<Food> queue;

    public Cook(Queue<Food> queue, String name) {
        super(name);
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            SleepUtil.randomSleep();    //模拟厨师炒菜时间
            Food food = new Food();
            System.out.println(getName() + " 生产了" + food);
            synchronized (queue) {
                while (queue.size() > 4) {
                    try {
                        System.out.println("队列元素超过5个,为:" + queue.size() + " " + getName() + "抽根烟等待中");
                        queue.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                queue.add(food);
                queue.notifyAll();
            }
        }
    }
}

我们说每一个厨师Cook都是一个线程,内部维护了一个名叫queue的队列。在run方法中是一个死循环,代表不断的生产Food。他每生产一个Food后,都要判断queue队列中元素的个数是不是大于4,如果大于4的话,就调用queue.wait()等待,如果不大于4的话,就把创建号的Food对象放到queue队列中,由于可能多个线程同时访问queue的各个方法,所以对这段代码用queue对象来加锁保护。当向队列添加完刚创建的Food对象之后,就可以通知queue这个锁对象关联的等待队列中的服务员线程们可以继续端菜了。

然后我们再用java定义一下服务员:

class Waiter extends Thread {

    private Queue<Food> queue;

    public Waiter(Queue<Food> queue, String name) {
        super(name);
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            Food food;
            synchronized (queue) {
                while (queue.size() < 1) {
                    try {
                        System.out.println("队列元素个数为: " + queue.size() + "," + getName() + "抽根烟等待中");
                        queue.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                food = queue.remove();
                System.out.println(getName() + " 获取到:" + food);
                queue.notifyAll();
            }

            SleepUtil.randomSleep();    //模拟服务员端菜时间
        }
    }
}

每个服务员也是一个线程,和厨师一样,都在内部维护了一个名叫queue的队列。在run方法中是一个死循环,代表不断的从队列中取走Food。每次在从queue队列中取Food对象的时候,都需要判断一下队列中的元素是否小于1,如果小于1的话,就调用queue.wait()等待,如果不小于1的话,也就是队列里有元素,就从队列里取走一个Food对象,并且通知与queue这个锁对象关联的等待队列中的厨师线程们可以继续向队列里放入Food对象了。
在厨师和服务员线程类都定义好了之后,我们再创建一个Restaurant类,来看看在餐馆里真实发生的事情:

public class Restaurant {

    public static void main(String[] args) {

        Queue<Food> queue = new LinkedList<>();
        new Cook(queue, "1号厨师").start();
        new Cook(queue, "2号厨师").start();
        new Cook(queue, "3号厨师").start();
        new Waiter(queue, "1号服务员").start();
        new Waiter(queue, "2号服务员").start();
        new Waiter(queue, "3号服务员").start();
    }
}

我们在Restaurant中安排了3个厨师和3个服务员,大家执行一下这个程序,会发现在如果厨师生产的过快,厨师就会等待,如果服务员端菜速度过快,服务员就会等待。但是整个过程厨师和服务员是没有任何关系的,它们是通过队列queue实现了所谓的解耦。

这个过程虽然不是很复杂,但是使用中还是需要注意一些问题:

  • 我们这里的厨师和服务员使用同一个锁queue。

使用同一个锁是因为对queue的操作只能用同一个锁来保护,假设使用不同的锁,厨师线程调用queue.add方法,服务员线程调用queue.remove方法,这两个方法都不是原子操作,多线程并发执行的时候会出现不可预测的结果,所以我们使用同一个锁来保护对queue这个变量的操作,这一点我们在唠叨设计线程安全类的时候已经强调过了。

  • 厨师和服务员线程使用同一个锁queue的后果就是厨师线程和服务员线程使用的是同一个等待队列。

但是同一时刻厨师线程和服务员线程不会同时在等待队列中,因为当厨师线程在wait的时候,队列里的元素肯定是5,此时服务员线程肯定是不会wait的,但是消费的过程是被锁对象queue保护的,所以在一个服务员线程消费了一个Food之后,就会调用notifyAll来唤醒等待队列中的厨师线程们;当消费者线程在wait的时候,队列里的元素肯定是0,此时厨师线程肯定是不会wait的,生产的过程是被锁对象queue保护的,所以在一个厨师线程生产了一个Food对象之后,就会调用notifyAll来唤醒等待队列中的服务员线程们。所以同一时刻厨师线程和服务员线程不会同时在等待队列中。

  • 在生产和消费过程,我们都调用了SleepUtil.randomSleep();。

我们这里的生产者-消费者模型是把实际使用的场景进行了简化,真正的实际场景中生产过程和消费过程一般都会很耗时,这些耗时的操作最好不要放在同步代码块中,这样会造成别的线程的长时间阻塞。如果把生产过程和消费过程都放在同步代码块中,也就是说在一个厨师炒菜的同时不允许别的厨师炒菜,在一个服务员端菜的同时不允许别的服务员端菜,这个显然是不合理的,大家需要注意这一点。

以上就是wait/notify机制的一个现实应用:生产者-消费者模式的一个简介。

Java并发编程系列21:多线程之生产者和消费者模式(使用BlockingQueue实现) Java多线程之生产者和消费者模式(使用BlockingQueue实现) 阅读详情

相关推荐

Java并发编程系列20:多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)

Java多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)

fen_fen的专栏 1803

SleepUtils工具类 方便直接调用Java线程sleep方法不需要捕获异常

SleepUtils工具类 方便直接调用Java线程sleep方法。

思念十年后 468

Java并发编程系列19:多线程之生产者和消费者模式_管程法(wait/notify)

生产者和消费者模式:这其实是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件 对于生产者,没有生产产品之前,要通知消费者等待。而生产了产品之后,又需要马上通知消费者消费。 对于消费者,消费之后,要通知生产者已经消费完成,需要继续生产新的产品给消费者消费。 在生产者和消费者问题中,仅有synchronizede是不够的 synchronized可阻止并发更新同一个共享资源,实现了同步 synchronized不能用来实现不同线程之间的消息传递(通信) ...

fen_fen的专栏 520

线程中方法睡眠对执行线程的影响

异步编排中线程中方法是否睡眠对执行线程

qq_50907269的博客 612

Java并发编程系列18:多线程之生产者和消费者模式_信号灯法(wait/notify通知机制)

生产者消费者模式 生产者消费者问题(Producer-consumer problem),也称为有限缓冲问题(Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个共享大小缓冲区的线程---既所谓的“生产者”和“消费者”----在实际运行时会发生的问题。生产者的主要作用时生成一定量的数据放到缓冲区中,然后重复此过程。以此同时,消费者也在缓冲区消费这些数据。该问题的关键是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消费数据。 ...

fen_fen的专栏 2074

揭秘Java并发编程模式:探索生产者-消费者、读写锁等经典模式

在现代软件开发中,Java并发编程模式是一项关键技术,它可以提高程序的并发性和性能。本文将揭秘Java并发编程模式,探索生产者-消费者、读写锁等经典模式,帮助读者深入理解并应用这些模式。本文将全面解析Java并发编程模式,重点探索生产者-消费者模式和读写锁模式等经典模式。通过源代码解析、应用场景案例、优缺点分析、类代码方法介绍和具体的Java代码测试用例,帮助读者灵活应用这些模式。在本节中,我们将介绍Java并发编程模式的重要性,并概述生产者-消费者模式和读写锁模式等经典模式的应用场景。

喵手的博客 1093

Java并发编程 【生产者消费者模式的实现】

最简单的实现方式是利用阻塞队列,废话不多说,上代码: wait、notify、notifyAll是Object对象的属性,并不属于线程。我们先解释这三个的一个很重要的概念 wait:使持有该对象的线程把该对象的控制权交出去,然后处于等待状态,并释放锁 notify:通知某个正在等待这个对象的控制权的线程可以继续运行,同样也是释放锁 notifyAll:会通知所有等待这个对象控制权的线程继续运行 ...

半 岛 码 农 的 博 客 1256

Java并发编程模式:生产者消费者模式的6种实现方式

本文旨在帮助Java开发者系统掌握生产者消费者模式的多种实现方式,理解每种方案的底层原理、适用场景及优缺点。内容覆盖从基础的到高性能的Disruptor,再到现代异步编程的,适合从初级到高级的全阶段开发者学习。用生活化案例解释核心概念分6种方式详细讲解实现原理与代码总结每种方案的适用场景与优缺点生产者:生成数据的线程(厨师)消费者:处理数据的线程(服务员)缓冲区:协调双方速度的中间容器(取餐窗口)线程安全:保证多线程操作数据一致的机制从基础的到高性能的Disruptor,再到异步的。

Java大师兄的博客 1047

Java 并发编程 生产者消费者模式

本文部分摘自《Java 并发编程的艺术》 模式概述 在线程的世界里,生产者就是生产数据的线程,消费者就是消费数据的数据。生产者和消费者彼此之间不直接通信,而是通过阻塞队列进行通信,所以生产者生产完数据后不用等待消费者处理,而是直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列取,阻塞队列相当于一个缓冲区,平衡了生产者和消费者的处理能力 模式实战 假设现有需求:把各部门的邮件收集起来,统一处理归纳。可以使用生产者 - 消费者模式,启动一个线程把所有邮件抽取到队列中,消费者启动多个线程处理邮..

低吟不作语的博客 447

实战案例:用多智能体系统模拟房地产市场的架构设计

房地产市场是典型的复杂自适应系统:买方纠结“要不要上车”、卖方盘算“挂多少钱能快速成交”、中介忙着“撮合两边赚佣金”、政府琢磨“怎么调政策稳房价”——每一个参与者的微小决策,最终都会汇聚成“房价暴涨”“成交冰点”这样的宏观现象。传统的计量经济学模型(比如线性回归)假设“所有人都是理性人”,但现实中没人能算清所有变量——你可能因为“同事买了学区房”就跟风,也可能因为“怕失业”而放弃买房。这时候,多智能体系统(MAS)

移动开发前沿的博客 1125

hi3519dv500 os04a10输入调试

因该sensor接在soc端的iic6,在驱动中(Hi3519DV500_SDK_V2.0.1.1\smp\a55_linux\source\mpp\cbb\isp\user\sensor\hi3519dv500\omnivision_os04a10\os04a10_sensor_ctl.c)注意总线的选择。mem_process_isolation=1 改为 mem_process_isolation=0。2、OT_MIPI_SET_HS_MODE配置为LANE_DIVIDE_MODE_1。

linus 3181

Java并发编程系列之十三:生产者-消费者模式

生产者-消费者模式指的是:生产者和消费者在同一个时间段共用同一段空间,在这段时间内,生产者负责往存储空间生产数据,而消费者则负责消费数据。实际上存在很多类似的场景:消息中间件就可以看做这种模式的应用,客户端请求负责把请求消息发送给消息中间件,然后由服务器负责从消息中间件获取请求并进行响应;还有网络编程中Socket也可以看做是生产者消费者模式的应用,etc。为了简化问题的研究,现在仅仅考虑一种简单的

rhwayfun专栏 5368

避坑指南:SpringBoot对接拉卡拉支付常见问题与解决方案(含SDK 1.0.6配置技巧)

本文是一份SpringBoot项目对接拉卡拉支付的实战避坑指南。针对SDK 1.0.6版本,详细剖析了从依赖管理、多环境配置、SDK初始化到支付请求构建、回调验签及生产监控的全流程常见问题,并提供了经过验证的解决方案与配置技巧,旨在帮助开发者高效、稳定地集成支付功能。

k5l6m的博客 332

java 生产者消费者_Java并发编程系列:生产者-消费者模式

目光从厕所转到饭馆,一个饭馆里通常都有好多厨师以及好多服务员,这里我们把厨师称为生产者,把服务员称为消费者,厨师和服务员是不直接打交道的,而是在厨师做好菜之后放到窗口,服务员从窗口直接把菜端走给客人就好了,这样会极大的提升工作效率,因为省去了生产者和消费者之间的沟通成本。从java的角度看这个事情,每一个厨师就相当于一个 生产者 线程,每一个服务员都相当于一个 消费者 线程,而放菜的窗口就相当于一...

weixin_40001519的博客 72

通讯软件002——快速使用modscan进行modbus调试

快速使用modscan进行modbus调试

zhouwl72的博客 1033

如何在Hyper-V、Virtual PC等虚拟机中使用USB设备

今天网盾科技给大家分享一篇在Hyper-V、Virtual PC等虚拟机中使用USB Over network软件用USB设备的方法。 当前Hyper-V Server与Microsoft Virtual PC的虚拟机,不支持USB的设备,如果你有USB设备需要在虚拟机中使用,例如USB的加密狗、智能卡、网上银行的U盾等,可以通过USB Over Network软件,通过网络,使用USB设备。 USB Over Network是一款“客户/服务器”软件,是这么一款功能强大 USB 设备共享软件。它使用方

wangdunkeji_idc的博客 5002

Java 入门指南:Java 并发编程模式 —— 生产者-消费者模式

生产者/消费者模式是一种重要的多线程设计模式,它通过引入共享队列来实现生产者和消费者之间的解耦。这种模式不仅可以提高系统的并发性和灵活性,还可以平滑负载,适用于多种应用场景。通过使用阻塞队列、wait/notify 机制或者 Exchanger,可以方便地实现生产者/消费者模式,并解决多线程环境下数据生产和消费的问题。

热带鱼的技术博客 1924

本地Pycharm连接远程服务器详细配置过程(直接在本地使用服务器显卡,很棒)

相信很多人都遇见过这种情况:实验室成员使用同一台服务器,每个人拥有自己的独立账号,我们可以使用服务器更好的配置完成实验,毕竟自己哪有money拥有自己的3090呢。

NorthSmile的博客 4万+

java实现生产者消费者模式

一: 什么是生产者消费者模型 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。 简单来说: 生产者消费者模型就是指,在一个系统中,存在两种角色,一个为生产者,一个为消费者,通过一个缓冲区(仓库)进行通信,生产者将生产的产品放入仓库,消费...

向上的"狼"的博客 8207

Windows 下 OpenClaw(小龙虾) 安装全记录:从零到一的保姆级图文教程(持续更新中)

本文主要介绍了Windows 下 OpenClaw 安装全记录:从零到一的保姆级图文教程,希望能对学习使用OpenClaw 的同学们有所帮助。 文章目录 1. 背景 2. 实战教程 2.1 步骤一 安装Node.js 2.2 步骤二:安装并配置OpenClaw 2.3 步骤三:配置模型 2.4 步骤四:对话 3. 后续使用步骤

weixin_43178406的博客 16万+

统计滤波器

认知有限,望大家多多包涵,有什么问题也希望能够与大家多交流,共同成长!本文先对统计滤波器做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章提示:以下是本篇文章正文内容。

qq_35635374的博客 1645

Java设计模式之生产者/消费者模式

一、什么是生产者/消费者模式? 某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程等)。产生数据的模块,就形象地称为生产者;而处理数据的模块,就称为消费者。在生产者与消费者之间在加个缓冲区,我们形象的称之为仓库,生产者负责往仓库了进商品,而消费者负责从仓库里拿商品,这就构成了生产者消费者模式。结构图如下: 二、生产者消费者模式的优点: 1、解耦: 由于有缓冲区的存在,生产者和消费者之间不直接依赖,耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的

红日 5072

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

java并发编程——异步模式之生产者/消费者

异步模式之生产者/消费者 与前面的保护性暂停中的 GuardObject 不同,不需要产生结果和消费结果的线程一一对应 消费队列可以用来平衡生产和消费的线程资源 生产者仅负责产生结果数据,不关心数据该如何处理,而消费者专心处理结果数据 消息队列是有容量限制的,满时不会再加入数据,空时不会再消耗数据 JDK 中各种阻塞队列,采用的就是这种模式 说明,t1,t2,t3是生产者,t4是消费者,这里的t4不一定是一个,有可能是多个。 实现 import lombok.extern.slf4j.Slf4j; i

mirana的专栏 623

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

设计模式之生产者消费者模式

本文通过`wait()`和`notify()`方法,实现和分析消费者和生产者模式,此模式优雅的实现了生产者和消费者的解耦,并且支持并发。通过手写一份生产者消费者模式的代码,进行讲解。学习领悟了这种设计模式,才可以真正理解`消息中间件`实现的底层思想,比如Kafka、RocketMQ、RabbitMQ等。

五道口 2867

生产者消费者模式

生产者消费者模式被广泛应用于解耦,消息队列等场景.生产者与消费者之间需要一个中介来调度,否则可能会出现产能过剩等情况,于是便诞生了生产者消费者模式.来实现生产者消费者模式,因为它封装了大量的同步细节,简化了开发。已经是最简单的解决方案,但我们依然可以通过底层的同步工具实现生产者消费者模式。提供了内置的线程安全机制,能够自动阻塞线程,直到队列有空余空间或者有数据可消费。这种方式适用于简单的线程协作,尽管它提供了基本的同步机制,但相比。这种方式提供了更多的灵活性,适用于更复杂的并发控制场景。

dm菜鸟编程的专栏 989

❤️并发编程❤️生产者消费者模式实现的三种方式

生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消 费者彼此之间不直接通信,而是通过阻塞队列来进行通信,所以生产者生产完数据之后不用 等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取, 阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。

发现问题,面对问题,分析问题,解决问题,总结问题 1667
上一篇: Java 中的多线程你只要看这一篇就够了
下一篇: Java高并发缓存架构,缓存雪崩、缓存穿透之谜
Java_No2
博客等级 码龄7年 20粉丝 109原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值