Python基础之生产者与消费者模型

简介

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

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

实例1：基于队列实现生产者消费者模型

from multiprocessing import Process, Queue
import time
import random
import os


def consumer(q):
    while 1:
        res = q.get()
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))


def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "食物%s" % i
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))


if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()
    print("主进程结束")

结果：（略）

分析：此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。

解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环。

实例2：生产者消费者模型之改进版

from multiprocessing import Process, Queue
import time
import random
import os


def consumer(q):
    while 1:
        res = q.get()
        if res is None:  # 收到信号就结束
            break
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))


def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "食物%s" % i
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))
    q.put(None)  # for结束后发信号


if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()
    print("主进程结束")

结果：（略）

注意：结束信号None，不一定要由生产者发，主进程里同样可以发，但主进程需要等生产者结束后才应该发送该信号。

实例3：生产者消费者改进版之主进程发送结束请求

from multiprocessing import Process, Queue
import time
import random
import os


def consumer(q):
    while 1:
        res = q.get()
        if res is None:  # 收到信号就结束
            break
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))


def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "食物%s" % i
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))


if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()

    p.join()
    q.put(None)  # for结束后发信号
    print("主进程结束")

结果：（略）

如果有多个生产者和多个消费者时，我们可以这样解决：

实例：多个生产者与消费者

from multiprocessing import Process, Queue
import time
import random
import os


def consumer(q):
    while 1:
        res = q.get()
        if res is None:  # 收到信号就结束
            break
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))


def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "食物%s" % i
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))


if __name__ == '__main__':
    q = Queue()
    p_one = Process(target=producer, args=(q,))
    p_two = Process(target=producer, args=(q,))
    p_thr = Process(target=producer, args=(q,))

    c_one = Process(target=consumer, args=(q,))
    c_two = Process(target=consumer, args=(q,))
    c_thr = Process(target=consumer, args=(q,))
    c_fou = Process(target=consumer, args=(q,))

    p_one.start()
    p_two.start()
    p_thr.start()

    c_one.start()
    c_two.start()
    c_thr.start()
    c_fou.start()

    p_one.join()
    p_two.join()
    p_thr.join()

    q.put(None)  # 四次发送结束信号
    q.put(None)
    q.put(None)
    q.put(None)

    print("主进程结束")

这个方法确实很low，但是重在理会意图，同学们有更好的方法可以自己尝试。

JoinableQueue([maxsize]) 实现生产者消费者模型

创建可连接的共享进程队列。这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：

• q.task_done()：使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。
• q.join()：生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。

下面的例子说明如何建立永远运行的进程，使用和处理队列上的项目。生产者将项目放入队列，并等待它们被处理。

from multiprocessing import Process, JoinableQueue
import time
import random
import os


def consumer(q):
    while 1:
        res = q.get()
        if res is None:  # 收到信号就结束
            break
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))


def producer(name, q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "%s %s" % (name, i)
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))
    q.join()


if __name__ == '__main__':
    q = JoinableQueue()
    p_one = Process(target=producer, args=("包子", q))
    p_two = Process(target=producer, args=("馒头", q))
    p_thr = Process(target=producer, args=("大便", q))

    c_one = Process(target=consumer, args=(q,))
    c_two = Process(target=consumer, args=(q,))

    c_one.daemon = True
    c_two.daemon = True

    p_lst = [p_one, p_two, p_thr, c_one, c_two]

    for p in p_lst:
        p.start()

    p_one.join()
    p_two.join()
    p_thr.join()

    print("主进程结束")

结果：（略）

分析：主进程等--->p1,p2,p3等---->c1,c2。

p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据。

因而c1,c2也没有存在的价值了,不需要继续阻塞在进程中影响主进程了。应该随着主进程的结束而结束,所以设置成守护进程就可以了。