生产者、消费者问题，python实现

最新推荐文章于 2024-08-08 08:27:49 发布
原创 最新推荐文章于 2024-08-08 08:27:49 发布 · 2k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个经典的线程同步问题——生产者消费者模型的Python实现。通过使用锁对象确保线程安全，实现生产者向缓冲池放入产品，消费者从中取出产品的过程。代码示例展示了如何在多线程环境下控制缓冲池的状态。

      生产者、消费者问题，经典的线程同步问题：假设有一个缓冲池(列表)，生产者往里面放东西，消费者从里面取，规则是：列表为空的时候，生产者才能放东西；列表不为空的时候，消费者才能取东西；为了简单起见，暂定缓冲池中最多只能有一个产品。这里生产者和消费者共同操作一个资源：缓冲池，因此每次操作的时候，需要给资源加锁，操作结束时，释放锁，这样才能做到资源同步。使用python实现，需要继承Thread类，获取锁对象，代码如下：

from threading import Thread
from threading import Lock
import time,random

pro_list = []
lock = Lock()

class Producer(Thread):
    def run(self):
        global pro_list
        while True:
            i = random.randint(0, 100)
            lock.acquire()
            if len(pro_list) > 0:
                print "!--product still in list, wait consumer to get it.."
            else:
                pro_list.append(i)
                print ":::Producer put:", pro_list[0]
            lock.release()
            time.sleep(2)

class Consumer(Thread):
    def run(self):
        global pro_list
        while True:
            lock.acquire()
            if len(pro_list) == 0:
                print "!--No product now, wait producer put in..."
            else:
                print ":::Consumer fetch:", pro_list[0]
                pro_list.pop(0)
            lock.release()
            time.sleep(2)

Producer().start()
Producer().start()
Consumer().start()
Producer().start()
Producer().start()
Consumer().start()
Consumer().start()

这里使用多个生产者和消费者，共同操作缓冲池，部分执行结果如下：

:::Producer put: 12
!--product still in list, wait consumer to get it..
:::Consumer fetch: 12
:::Producer put: 75
!--product still in list, wait consumer to get it..
:::Consumer fetch: 75
!--No product now, wait producer put in...
:::Producer put: 28
!--product still in list, wait consumer to get it..
!--product still in list, wait consumer to get it..
:::Consumer fetch: 28
:::Producer put: 94
:::Consumer fetch: 94

Python多线程编程：生产者-消费者模型实现
带你成为别人眼中的大佬！
04-04 807
生产者-消费者模型描述了一个生产者和一个或多个消费者共享同一个固定大小的缓冲区，并通过同步机制协调数据交换的过程。缓冲区的大小是固定的，当缓冲区满了时，生产者必须等待消费者取走一些数据后才能继续向缓冲区写入数据，反之亦然。在上面的代码中，Producer是生产者线程的实现，Consumer是消费者线程的实现，它们都继承自threading.Thread类，并重写了run方法。queue.Queue是Python标准库中提供的一个多线程队列类，它实现了一个简单的生产者-消费者模型。
Python 实现生产者-消费者问题（进程、线程、协程）
Bcdfxg的博客
06-07 3713
Python 实现生产者-消费者问题生产者-消费者问题详解Python 多线程Python 套接字 生产者-消费者问题详解 Python 多线程 Python 套接字
生产者消费者问题---python
baidu_35812512的博客
11-08 395
生产者消费者问题 生产者消费者问题属于线程同步问题 有两个线程，分别是生产者和消费者，两者共有一个缓冲区。 生产者负责向缓冲区中添加数据，消费者从缓冲区读取数据，当缓冲区已满时，生产者暂停添加；当缓冲区为空时，消费者暂停读取。由于操作的是同一个缓冲区，所以为了避免冲突，需要在操作时，对缓冲区加锁。 import random import threading from time impo...
Python中的生产者消费者问题
wakeUpJava
12-05 1471
我们将使用Python线程来解决Python中的生产者—消费者问题。这个问题完全不像他们在学校中说的那么难。 如果你对生产者—消费者问题有了解，看这篇博客会更有意义。 为什么要关心生产者—消费者问题： 可以帮你更好地理解并发和不同概念的并发。信息队列中的实现中，一定程度上使用了生产者—消费者问题的概念，而你某些时候必然会用到消息队列。 当我们在使用线程时，你可以学习以下的线
python中生产者消费者问题
mfansheng的博客
08-14 3076
•生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。 •该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。 •生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。 •消费者也在缓冲区消耗这些数据。...
Python实现的生产者、消费者问题完整实例
12-25
本文实例讲述了Python实现的生产者、消费者问题。分享给大家供大家参考，具体如下： 生产者、消费者问题，经典的线程同步问题：假设有一个缓冲池(列表)，生产者往里面放东西，消费者从里面取，规则是：列表为空的...
理解生产者消费者模型及在Python编程中的运用实例
09-21
在Python中，可以通过`threading`和`queue`模块来实现生产者消费者模型。下面是一个使用队列实现简单生产者消费者模型的示例： ```python import time import threading from queue import Queue class Consumer...
详解Python 模拟实现生产者消费者模式的实例
09-21
在Python中，我们可以利用线程、队列以及循环等知识来模拟实现生产者消费者模式。以下是一个简单的实例： 首先，我们需要导入必要的库： ```python import queue import time import threading import random ``` ...
python之生产者消费者模型实现详解
09-18
在编程领域，生产者消费者问题是一个经典的多线程同步问题。它描述的是生产者生产数据，消费者消费数据，而生产者和消费者之间通过共享内存（缓冲区）进行数据交换。这个模型的目的是避免直接通信带来的耦合性，同时...
Python -- 生产者消费者
热门推荐
MarkAdc的博客
04-14 5万+
生产者消费者模式初体验
[原]初学python 协程(无锁生产者&消费者)
weixin_34050519的博客
05-31 150
引言：前几天看了一点InfoQ上大神们很多的总结，服务编程范式以这样的方式进化多进程--->多线程--->非阻塞--->协程。 说说协程，找了一些关于GreenLet的资料，协程也称作微线程，是比线程还小的一种执行体。 线程确实执行体就是一个函数，在用户空间看来，但是在内核中线程也是一个进程，LWP所谓的轻量级进程，线程也存在自己的上下文运行环境。 协程不同于线程的是，线程...
Python 生产者消费者问题
Jeff
05-08 636
生产者消费之模型就是,比如一个包子铺,中的顾客吃包子,和厨师做包子, 不可能是将包子一块做出来,在给顾客吃,但是单线程只能这麽做, 所以用多线程来执行,厨师一边做包子,顾客一边吃包子, 当顾客少时,厨师做的包子就放在一个容器中,等着顾客来吃, 当顾客多的时候,就从容器中先取出来给顾客吃,厨师继续做包子 用队列来模拟这个容器 1. 当做完一个包子后就要给顾客发送一个信号,表示已经做完,让他们吃包子 ...
python实现生产者和消费者问题
yashijiayou的博客
07-26 474
#生产者和消费者问题 from threading import Thread,current_thread import time import random #from queue import Queue from multiprocessing import Queue,Process queue=Queue(5)#队列最多放五个元素 class Producerthread(Thread...
Python使用yield协程实现生产者消费者问题
引用原创内容标明出处即可
11-08 2596
子程序就是协程的一种特例。 ——唐纳德·克努特
python 中生产者与消费者 模式
阿常呓语的专栏
09-30 5611
生产者与消费者 模式 摘要: 最近一段时间,写了一些生产者与消费者模型, 特此此文 作为总结. 文中总结了不同的 生产者与消费者的情况. 一个生产者, 多个消费者,与一个生产者,多个消费者 的编程模式. 一. 生产者与消费者 在软件开发的过程中，经常碰到这样的场景： 某些模块负责生产数据，这些数据由其他模块来负责处理（此处的模块可能是：函数、线程、进程等). 产生数据的模块称为生产者,而处...
生产者与消费者问题（python）
qq_43608549的博客
08-13 2571
生产者与消费者问题（python） 其主要是针对多线程threading问题的实际场景 生产者消费者模型： 生产者------> 缓存<-------- 消费者 具体代码详解如下： import threading import time import random count=0 #使用共享区的模拟变量 condition = threading.Condition() c...
python生产者消费者_Python实现的生产者、消费者问题完整实例
weixin_39774682的博客
12-02 700
本文实例讲述了Python实现的生产者、消费者问题。分享给大家供大家参考，具体如下：生产者、消费者问题，经典的线程同步问题：假设有一个缓冲池(列表)，生产者往里面放东西，消费者从里面取，规则是：列表为空的时候，生产者才能放东西；列表不为空的时候，消费者才能取东西；为了简单起见，暂定缓冲池中最多只能有一个产品。这里生产者和消费者共同操作一个资源：缓冲池，因此每次操作的时候，需要给资源加锁，操作结束时...
生产者消费者 python_python中生产者消费者模式
weixin_39694264的博客
12-22 138
问题：1、为什么要使用生产者消费者模式？一直生产,一直消费,中间有阀值,避免供求关系不平衡,导致出现问题。#线程安全问题，要是线程同时来，听谁的#锁：一种数据结构 队列:先进线出 栈：先进后出2、生产者消费者模式作用？解耦：让程序各模块之间的关联性降到最低异步、并发平衡生产者和消费者之间的速度差异。•生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。•该问题描述了两个共享固定大小...
Python 生产者消费者模型
小屁孩大帅-保密的博客
08-08 531
1. 简介生产者和消费者问题是线程模型中的经典问题：生产者和消费者共享同一个存储空间生产者往存储空间中添加产品，消费者从存储空间中取走产品当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞Python 的内置模块 queue 提供了对生产者和消费者模型的支持，模块 queue 定义了类 Queue，类 Queue 表...
生产者消费者问题python实现代码
最新发布
03-19
### 使用Python实现生产者消费者模型 以下是使用`queue.Queue`和多线程来实现生产者消费者模型的一个简单示例： ```python import threading import time import random from queue import Queue # 定义缓冲区大小 BUFFER_SIZE = 5 # 创建队列作为共享缓冲区 buffer_queue = Queue(BUFFER_SIZE) def producer(buffer, event): """生产者函数""" count = 0 while True: item = f"Item-{count}" if buffer.full(): print(f"[Producer] Buffer is full. Waiting... {item}") event.wait() # 如果缓冲区满了，则等待消费者的信号 event.clear() print(f"[Producer] Producing {item}...") buffer.put(item) print(f"[Producer] Added to buffer: {item}. Current size: {buffer.qsize()}") count += 1 time.sleep(random.uniform(0.5, 1)) # 随机延迟模拟生产时间 def consumer(buffer, event): """消费者函数""" while True: if buffer.empty(): print("[Consumer] Buffer is empty. Notifying producers...") event.set() # 缓冲区为空时通知生产者继续工作 continue item = buffer.get() print(f"[Consumer] Consuming {item}...") print(f"[Consumer] Removed from buffer: {item}. Current size: {buffer.qsize()}") time.sleep(random.uniform(1, 2)) # 随机延迟模拟消费时间 if __name__ == "__main__": # 创建事件对象用于线程间通信 event = threading.Event() # 启动生产者和消费者线程 producer_thread = threading.Thread(target=producer, args=(buffer_queue, event)) consumer_thread = threading.Thread(target=consumer, args=(buffer_queue, event)) producer_thread.daemon = True consumer_thread.daemon = True producer_thread.start() consumer_thread.start() # 主线程保持运行状态 try: while True: time.sleep(1) except KeyboardInterrupt: print("Program terminated by user.") ``` 上述代码展示了如何通过`threading`模块创建多个线程，并使用`Queue`类管理生产和消费的过程[^1]。 如果希望采用异步编程的方式实现生产者消费者模型，可以借助`asyncio`库完成。下面是一个基于`asyncio`的实现示例： ```python import asyncio import random # 设置缓冲区容量 BUFFER_LIMIT = 5 async def producer(queue): """异步生产者函数""" count = 0 while True: item = f"Product-{count}" await queue.put(item) print(f"[Producer] Produced {item}, current queue size: {queue.qsize()}") if queue.qsize() >= BUFFER_LIMIT: print("[Producer] Buffer limit reached! Pausing production...") await asyncio.sleep(random.uniform(1, 3)) # 模拟暂停生产 count += 1 await asyncio.sleep(random.uniform(0.5, 1)) # 控制生产速度 async def consumer(queue): """异步消费者函数""" while True: item = await queue.get() print(f"[Consumer] Consumed {item}, current queue size: {queue.qsize()}") queue.task_done() await asyncio.sleep(random.uniform(1, 2)) # 控制消费速度 async def main(): """主协程函数""" queue = asyncio.Queue(maxsize=BUFFER_LIMIT) tasks = [ asyncio.create_task(producer(queue)), asyncio.create_task(consumer(queue)) ] await asyncio.gather(*tasks) if __name__ == "__main__": asyncio.run(main()) ``` 此代码片段展示了一个基于`asyncio`的生产者消费者模型，其中生产者和消费者分别以独立的任务形式存在，并通过`asyncio.Queue`进行交互[^2]。 #### 关键点说明 - `queue.Queue`适用于传统的多线程环境下的生产者消费者问题。 - 对于高并发场景或者需要非阻塞操作的情况，推荐使用`asyncio.Queue`配合异步IO技术[^3]。 - 当缓冲区达到上限或下限时，可以通过条件变量或其他同步机制控制生产者和消费者的执行节奏[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值