关于生产者消费者模式

电玩女神 2023-03-03 08:45 116阅读 0赞

### 什么是生产者消费者模式 ###

在软件开发的过程中，经常碰到这样的场景：  
某些模块负责生产数据，这些数据由其他模块来负责处理（此处的模块可能是：函数、线程、进程等）。产生数据的模块称为生产者，而处理数据的模块称为消费者。在生产者与消费者之间的缓冲区称之为仓库。生产者负责往仓库运输商品，而消费者负责从仓库里取出商品，这就构成了生产者消费者模式。

**结构图如下**：

![preview][]

![format_png][]

> 为了大家容易理解，我们举一个寄信的例子。假设你要寄一封信，大致过程如下：  
> 　1、你把信写好——相当于生产者生产数据

2、你把信放入邮箱——相当于生产者把数据放入缓冲区  
　3、邮递员把信从邮箱取出，做相应处理——相当于消费者把数据取出缓冲区，处理数据

### 生产者消费者模式的优点 ###

*  **解耦**  
    假设生产者和消费者分别是两个线程。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。如果未来消费者的代码发生变化，可能会影响到生产者的代码。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。

> 举个例子，我们去邮局投递信件，如果不使用邮箱（也就是缓冲区），你必须得把信直接交给邮递员。有同学会说，直接给邮递员不是挺简单的嘛？其实不简单，你必须 得认识谁是邮递员，才能把信给他。这就产生了你和邮递员之间的依赖（相当于生产者和消费者的强耦合）。万一哪天邮递员 换人了，你还要重新认识一下（相当于消费者变化导致修改生产者代码）。而邮箱相对来说比较固定，你依赖它的成本就比较低（相当于和缓冲区之间的弱耦合）。

*  **并发**  
    由于生产者与消费者是两个独立的并发体，他们之间是用缓冲区通信的，生产者只需要往缓冲区里丢数据，就可以继续生产下一个数据，而消费者只需要从缓冲区拿数据即可，这样就不会因为彼此的处理速度而发生阻塞。

> 继续上面的例子，如果我们不使用邮箱，就得在邮局等邮递员，直到他回来，把信件交给他，这期间我们啥事儿都不能干（也就是生产者阻塞）。或者邮递员得挨家挨户问，谁要寄信（相当于消费者轮询）。

*  **支持忙闲不均**  
    当生产者制造数据快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中，慢慢处理掉。而不至于因为消费者的性能造成数据丢失或影响生产者生产。

> 我们再拿寄信的例子，假设邮递员一次只能带走1000封信，万一碰上情人节（或是圣诞节）送贺卡，需要寄出去的信超过了1000封，这时候邮箱这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮箱中，等下次过来时再拿走。

通过上面的介绍大家应该已经明白了生产者消费者模式。

### Python中的多线程编程 ###

在实现生产者消费者模式之前，我们先学习下Python中的多线程编程。  
线程是操作系统直接支持的执行单元，高级语言通常都内置多线程的支持，Python也不例外，并且Python的线程是真正的Posix Thread，而不是模拟出来的线程。  
Python的标准库提供了两个模块：\_thread和threading，\_thread是低级模块，threading是高级模块，对\_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。

下面我们先看一段在Python中实现多线程的代码。

import time,threading
    #线程代码
    class TaskThread(threading.Thread):
        def __init__(self,name):
            threading.Thread.__init__(self,name=name)
        def run(self):
            print('thread %s is running...' % self.getName())
    
            for i in range(6):
                print('thread %s >>> %s' % (self.getName(), i))
                time.sleep(1)
    
            print('thread %s finished.' % self.getName())
    
    taskthread = TaskThread('TaskThread')
    taskthread.start()
    taskthread.join()

> 下面是程序的执行结果：

thread TaskThread is running...
    thread TaskThread >>> 0
    thread TaskThread >>> 1
    thread TaskThread >>> 2
    thread TaskThread >>> 3
    thread TaskThread >>> 4
    thread TaskThread >>> 5
    thread TaskThread finished.

> TaskThread类继承自threading模块中的Thread线程类。构造函数的name参数指定线程的名字，通过重载基类run函数实现具体任务。

在简单熟悉了Python的线程后，下面我们实现一个生产者消费者模shi。

from Queue import Queue
    import random,threading,time
    
    #生产者类
    class Producer(threading.Thread):
        def __init__(self, name,queue):
            threading.Thread.__init__(self, name=name)
            self.data=queue
    
        def run(self):
            for i in range(5):
                print("%s is producing %d to the queue!" % (self.getName(), i))
                self.data.put(i)
                time.sleep(random.randrange(10)/5)
            print("%s finished!" % self.getName())
    
    #消费者类
    class Consumer(threading.Thread):
        def __init__(self,name,queue):
            threading.Thread.__init__(self,name=name)
            self.data=queue
        def run(self):
            for i in range(5):
                val = self.data.get()
                print("%s is consuming. %d in the queue is consumed!" % (self.getName(),val))
                time.sleep(random.randrange(10))
            print("%s finished!" % self.getName())
    
    def main():
        queue = Queue()
        producer = Producer('Producer',queue)
        consumer = Consumer('Consumer',queue)
    
        producer.start()
        consumer.start()
    
        producer.join()
        consumer.join()
        print 'All threads finished!'
    
    if __name__ == '__main__':
        main()

执行结果可能如下：

Producer is producing 0 to the queue!
    Consumer is consuming. 0 in the queue is consumed!
    Producer is producing 1 to the queue!
    Producer is producing 2 to the queue!
    Consumer is consuming. 1 in the queue is consumed!
    Consumer is consuming. 2 in the queue is consumed!
    Producer is producing 3 to the queue!
    Producer is producing 4 to the queue!
    Producer finished!
    Consumer is consuming. 3 in the queue is consumed!
    Consumer is consuming. 4 in the queue is consumed!
    Consumer finished!
    All threads finished!

> 因为多线程是抢占式执行的，所以打印出的运行结果不一定和上面的完全一致。

## ##

关于用python实现协程大致分为两种情况（个人能力范围内的见解），一种是多进程或者多线程 结合缓存（缓冲空间）来实现，当然缓存的方法不唯一，可以结合自己的业务做合理的选择，另外一种是协程（yield）来实现（又称为单线程模式），接下来就举几个例子来辅助说明一下：

协程（上面的例子是线程加队列实现）：

def producer(c):
        # 生产者产生消息，之后，yield到消费者执行
        c.send(None)    # 首先调用c.send(None)启动生成器
        n = 0
        while n < 5:
            n = n + 1
            print("[生产者] 正在生产 %s..." % n)
            r = c.send(n)   # 一旦生产了东西，通过c.send(n)切换到consumer执行
            print("[生产者] 消费者 return: %s" % r)
        c.close()
    
    def consumer():
        r = ''
        while True:
            n = yield r
            if not n:
                return
            print('[消费者] 正在消费 %s...' % n)
            r = '200 OK'
    
    c = consumer()  # 生成器对象
    producer(c)     # 生成器对象传入producer()函数

代码解读：

1.c = consumer(),不是调用函数def consumer(),而是声明一个生成器对象
       2.producer(c),将生成器对象传入函数def producer()
       3.此时,执行流程跑到：c.send(None),相当于c.__next__()方法,
         此时,执行流程跑到：def consumer(),遇到yield,返回结果 ''。
       4.此时,执行流程跑回：c.send(None),继续往下执行,n=0,
         由于n = 0,符合判断条件,print("[生产者] 正在生产 %s..." % n),
         就是输出结果中的第一条：[生产者] 正在生产 1...
         往下继续执行,r = c.send(n),此时n = 1,
         此时,执行流程跑到：def consumer(),由于生成器会记录上一次yield的状态,
         所以此时,def consumer()的 n = yield r 变为 n = send(1),即：n = 1,
         进入判断条件：if not n:,不符合,所以print([消费者] 正在消费 %s...' % n),
         就是输出结果中的第二条：[消费者] 正在消费 1...
         此时,执行流程跑回：def producer(c)中的print("[生产者] 消费者 return: %s" % r)
         就是输出结果的第三条：[生产者] 消费者 return: 200 OK
       5.之后的流程继续按照上面的步骤执行,直到produce决定不生产了,通过c.close()关闭consumer,整个过程结束。

进程加队列：

from multiprocessing import Process, Queue
    import time, random, os
    
    
    def consumer(q):
        while True:
            res = q.get()
            if res is None: break  # 收到结束信号则结束
            time.sleep(random.randint(1, 3))
            print('\033[45m%s 吃 %s\033[0m' % (os.getpid(), res))
    
    
    def producer(name, q):
        for i in range(2):
            time.sleep(random.randint(1, 3))
            res = '%s%s' % (name, i)
            q.put(res)
            print('\033[44m%s 生产了 %s\033[0m' % (os.getpid(), res))
    
    
    if __name__ == '__main__':
        q = Queue()
        # 生产者们:即厨师们
        p1 = Process(target=producer, args=('包子', q))
        p2 = Process(target=producer, args=('骨头', q))
        p3 = Process(target=producer, args=('泔水', q))
    
        # 消费者们:即吃货们
        c1 = Process(target=consumer, args=(q,))
        c2 = Process(target=consumer, args=(q,))
    
        # 开始
        p1.start()
        p2.start()
        p3.start()
        c1.start()
    
        p1.join()  # 必须保证生产者全部生产完毕,才应该发送结束信号
        p2.join()
        p3.join()
        q.put(None)  # 有几个消费者就应该发送几次结束信号None
        q.put(None)  # 发送结束信号
        print('主')
    #有几个消费者就需要发送几次结束信号：相当low

队列操作说明：

q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
    q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
     
    q.get_nowait():同q.get(False)
    q.put_nowait():同q.put(False)
    
    q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
    q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
    q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

### 小结 ###

本例通过Python实现了一个简单的生产者消费者模型。Python中的Queue模块已经提供了对线程同步的支持，所以本文并没有涉及锁、同步、死锁等多线程问题。

ps：可能细心的小伙伴会注意到，上述的代码中线程是单线程，那为什么不用多线程呢，不是不用，而是多线程需要注意很多安全问题，关于更多线程安全问题可以参考：[https://blog.csdn.net/weixin\_43790276/article/details/91069959][https_blog.csdn.net_weixin_43790276_article_details_91069959]

参考并致谢：

[https://www.cnblogs.com/earon/p/9601075.html][https_www.cnblogs.com_earon_p_9601075.html]

[https://blog.csdn.net/weixin\_42471384/article/details/82625657][https_blog.csdn.net_weixin_42471384_article_details_82625657]

[https://blog.csdn.net/darkdragonking/article/details/89208124][https_blog.csdn.net_darkdragonking_article_details_89208124]

[preview]: /images/20230208/e62143c258ec4cd5900697e084a0608e.png
[format_png]: /images/20230208/6670eaeabd904232903ddc1b5411ba64.png
[https_blog.csdn.net_weixin_43790276_article_details_91069959]: https://blog.csdn.net/weixin_43790276/article/details/91069959
[https_www.cnblogs.com_earon_p_9601075.html]: https://www.cnblogs.com/earon/p/9601075.html
[https_blog.csdn.net_weixin_42471384_article_details_82625657]: https://blog.csdn.net/weixin_42471384/article/details/82625657
[https_blog.csdn.net_darkdragonking_article_details_89208124]: https://blog.csdn.net/darkdragonking/article/details/89208124