生产者消费者模型

 

生产者消费者模型

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

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

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

    什么是生产者消费者模式

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

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

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

def procducer(q):
    for i in range(10):
        res='包子%s' %i
        time.sleep(0.5)
        q.put(res)
        print('%s 生产了 %s' %(os.getpid(),res))

def consumer(q):
    while True:
        res=q.get()
        print('%s 吃 %s' %(os.getpid(),res))
        time.sleep(random.randint(2,3))


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

    p.start()
    c.start()
    print('主')
#运行结果
主
17828 生产了 包子0
10356 吃 包子0
17828 生产了 包子1
17828 生产了 包子2
17828 生产了 包子3
17828 生产了 包子4
17828 生产了 包子5
10356 吃 包子1
17828 生产了 包子6
17828 生产了 包子7
17828 生产了 包子8
17828 生产了 包子9
10356 吃 包子2
10356 吃 包子3
10356 吃 包子4
10356 吃 包子5
10356 吃 包子6
10356 吃 包子7
10356 吃 包子8
10356 吃 包子9
#之后便一直在等待...

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

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

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

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

def procducer(q):
    for i in range(10):
        res='包子%s' %i
        time.sleep(0.5)
        q.put(res)
        print('%s 生产了 %s' %(os.getpid(),res))
    q.put(None)

def consumer(q):
    while True:
        res=q.get()
        if res is None:
            break
        print('%s 吃 %s' %(os.getpid(),res))
        time.sleep(random.randint(2,3))


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

    p.start()
    c.start()
    print('主')
#执行结果
主
17508 生产了 包子0
17420 吃 包子0
17508 生产了 包子1
17508 生产了 包子2
17508 生产了 包子3
17508 生产了 包子4
17508 生产了 包子5
17420 吃 包子1
17508 生产了 包子6
17508 生产了 包子7
17508 生产了 包子8
17508 生产了 包子9
17420 吃 包子2
17420 吃 包子3
17420 吃 包子4
17420 吃 包子5
17420 吃 包子6
17420 吃 包子7
17420 吃 包子8
17420 吃 包子9
#结束

def procducer(q):
    for i in range(10):
        res='包子%s' %i
        time.sleep(0.5)
        q.put(res)
        print('%s 生产了 %s' %(os.getpid(),res))

def consumer(q):
    while True:
        res=q.get()
        if res is None:
            break
        print('%s 吃 %s' %(os.getpid(),res))
        time.sleep(random.randint(2,3))


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

    p.start()
    c.start()

    p.join()
    q.put(None)
    print('主')
#结果
15936 生产了 包子0
16364 吃 包子0
15936 生产了 包子1
15936 生产了 包子2
15936 生产了 包子3
15936 生产了 包子4
16364 吃 包子1
15936 生产了 包子5
15936 生产了 包子6
15936 生产了 包子7
16364 吃 包子2
15936 生产了 包子8
15936 生产了 包子9
主 # 主进程里的操作要等生产者生产结束
16364 吃 包子3
16364 吃 包子4
16364 吃 包子5
16364 吃 包子6
16364 吃 包子7
16364 吃 包子8
16364 吃 包子9
#结束

 注意：不能以队列是否为空来判断消费者是否结束，因为可能生产者没有及时生产，队列开始时为空。

进程中的JoinableQueue队列

JoinableQueue 比Queue多了task_done() 与join()两个函数

task_done() 是用在get()后，告诉os, 我get完了，join()是说Queue里所有的items都被拿出来搞完了。

　　put时有一个计数器，在task_done的次数等于put次数时，生产者才会结束。join就是等待生产者结束。可以将消费者设为守护进程，因为生产者结束就意味着消费者已经把生产者生产的数据取完了。让消费者不必在等待

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

def procducer(food,q):
    for i in range(3):
        res='%s%s' %(food,i)
        time.sleep(0.5)
        q.put(res)
        print('%s 生产了 %s' %(os.getpid(),res))
    q.join()

def consumer(q):
    while True:
        res=q.get()
        print('%s 吃 %s' %(os.getpid(),res))
        time.sleep(random.randint(2,3))
        q.task_done()


if __name__ == '__main__':
    q=JoinableQueue()
    p1=Process(target=procducer,args=('包子',q,))
    p2=Process(target=procducer,args=('饺子',q,))
    p3=Process(target=procducer,args=('面条',q,))
    c1=Process(target=consumer,args=(q,))
    c2=Process(target=consumer,args=(q,))

    c1.daemon=True
    c2.daemon=True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()

    print('主',os.getpid())

17916 生产了 包子0
11876 吃 包子0
15576 生产了 饺子0
15812 吃 饺子0
5408 生产了 面条0
17916 生产了 包子1
15576 生产了 饺子1
5408 生产了 面条1
17916 生产了 包子2
15576 生产了 饺子2
5408 生产了 面条2
11876 吃 面条0
15812 吃 包子1
11876 吃 饺子1
15812 吃 面条1
11876 吃 包子2
15812 吃 饺子2
15812 吃 面条2
主 18108