Python进程相关（三）生产者消费者模型

一种解决问题的方法

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

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

# -*- coding: utf-8 -*-
"""
Created on Sun Dec 15 10:09:54 2019

@author: clt
"""
from multiprocessing  import Process,Queue
import time 
import random


#下边这种函数耦合的方式，有局限，生产的时候不能吃，吃的时候不能生产
'''
def producer(name):
    for i in range(10):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        print ('厨师[%s]生产了<%s>'%(name,res))
        consumer('clt',res)
        
        
        
def consumer(name,res):
    time.sleep(random.randint(1,3))
    print ('吃货[%s]吃了<%s>'%(name,res))
    
'''

def producer(name,q):
    for i in range(10):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        q.put(res)
        print ('厨师[%s]生产了<%s>'%(name,res))
        
        
        
def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
    
        print ('吃货[%s]吃了<%s>'%(name,res))
    
    
if __name__=='__main__':
    #队列
    q=Queue()
    #生产者们
    p1=Process(target=producer,args=('egon',q))
    #消费者们
    c1=Process(target=consumer,args=('clt',q))
    
    p1.start()
    c1.start()
    
    print('主进程')

结果
主进程
厨师[egon]生产了<包子0>
厨师[egon]生产了<包子1>
吃货[clt]吃了<包子0>
吃货[clt]吃了<包子1>
厨师[egon]生产了<包子2>
吃货[clt]吃了<包子2>
厨师[egon]生产了<包子3>
厨师[egon]生产了<包子4>
吃货[clt]吃了<包子3>
厨师[egon]生产了<包子5>
厨师[egon]生产了<包子6>
吃货[clt]吃了<包子4>
厨师[egon]生产了<包子7>
吃货[clt]吃了<包子5>
厨师[egon]生产了<包子8>
吃货[clt]吃了<包子6>
厨师[egon]生产了<包子9>
吃货[clt]吃了<包子7>
吃货[clt]吃了<包子8>
吃货[clt]吃了<包子9>

但上边的代码出现问题，主进程一直卡在那，因为消费者进程一直不死

• JoinableQueue与守护进程应用
  法一

# -*- coding: utf-8 -*-
"""
Created on Sun Dec 15 10:09:54 2019

@author: clt
"""
from multiprocessing  import Process,Queue
import time 
import random


#下边这种函数耦合的方式，有局限，生产的时候不能吃，吃的时候不能生产
'''
def producer(name):
    for i in range(10):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        print ('厨师[%s]生产了<%s>'%(name,res))
        consumer('clt',res)
        
        
        
def consumer(name,res):
    time.sleep(random.randint(1,3))
    print ('吃货[%s]吃了<%s>'%(name,res))
    
'''

def producer(name,q):
    for i in range(10):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        q.put(res)
        print ('厨师[%s]生产了<%s>'%(name,res))
        
        
        
def consumer(name,q):
    while True:
        res=q.get()
        if res is None:
            break
        time.sleep(random.randint(1,3))
    
        print ('吃货[%s]吃了<%s>'%(name,res))
    
    
if __name__=='__main__':
    #队列
    q=Queue()
    #生产者们
    p1=Process(target=producer,args=('egon',q))
    #消费者们
    c1=Process(target=consumer,args=('clt',q))
    
    p1.start()
    c1.start()
    
    
    p1.join()     #保证厨师运行完了
    q.put(None)
    print('主进程')
    
结果：
厨师[egon]生产了<包子0>
厨师[egon]生产了<包子1>
吃货[clt]吃了<包子0>
吃货[clt]吃了<包子1>
厨师[egon]生产了<包子2>
吃货[clt]吃了<包子2>
厨师[egon]生产了<包子3>
吃货[clt]吃了<包子3>
厨师[egon]生产了<包子4>
吃货[clt]吃了<包子4>
厨师[egon]生产了<包子5>
吃货[clt]吃了<包子5>
厨师[egon]生产了<包子6>
厨师[egon]生产了<包子7>
吃货[clt]吃了<包子6>
厨师[egon]生产了<包子8>
吃货[clt]吃了<包子7>
厨师[egon]生产了<包子9>
主进程
吃货[clt]吃了<包子8>
吃货[clt]吃了<包子9>

这次就能保证所有进程运行结束

如果多个生产者和消费者：
法一：有几个生产者就join几次，有几个消费者就发几次None信号
否则主进程就一直不结束

# -*- coding: utf-8 -*-
"""
Created on Sun Dec 15 10:09:54 2019

@author: clt
"""
from multiprocessing  import Process,Queue
import time 
import random

def producer(name,q):
    for i in range(2):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        q.put(res)
        print ('厨师[%s]生产了<%s>'%(name,res))
        
        
        
def consumer(name,q):
    while True:
        res=q.get()
        if res is None:
            break
        time.sleep(random.randint(1,3))
    
        print ('吃货[%s]吃了<%s>'%(name,res))
    
    
if __name__=='__main__':
    #队列
    q=Queue()
    #生产者们
    p1=Process(target=producer,args=('ccc',q))
    p2=Process(target=producer,args=('bbb',q))
    p3=Process(target=producer,args=('aaa',q))
   
    #消费者们
    c1=Process(target=consumer,args=('ccc',q))
    c2=Process(target=consumer,args=('xxx',q))
    c3=Process(target=consumer,args=('yyy',q))
    
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    c3.start()
    
    
    p1.join()     #保证厨师正常运行完了
    p2.join()
    p3.join()
         
    q.put(None)   #有几个消费者就发几个结束信号，因为放一个就被取一个取走了
    q.put(None)
    q.put(None)
    
    print('主进程')

结果：
厨师[ccc]生产了<包子0>
厨师[bbb]生产了<包子0>
吃货[xxx]吃了<包子0>
厨师[aaa]生产了<包子0>
厨师[ccc]生产了<包子1>
吃货[ccc]吃了<包子0>
厨师[bbb]生产了<包子1>
吃货[xxx]吃了<包子1>
吃货[ccc]吃了<包子1>
吃货[yyy]吃了<包子0>
厨师[aaa]生产了<包子1>
主进程
吃货[xxx]吃了<包子1>

上边方法一太low
法二，是用joinable

# -*- coding: utf-8 -*-
"""
Created on Sun Dec 15 10:09:54 2019

@author: clt
"""
from multiprocessing  import Process,JoinableQueue
import time 
import random


def producer(name,q):
    for i in range(2):
        res='包子%s'  %i
        time.sleep(random.randint(1,3))
        q.put(res)
        print ('厨师[%s]生产了<%s>'%(name,res))
        

        
        
        
def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
    
        print ('吃货[%s]吃了<%s>'%(name,res))
        q.task_done()  #每取走一个  发一个信号 给join发
    
    
if __name__=='__main__':
    #队列
    q=JoinableQueue()   #根本原理还是发信号  但是是消费者发信号
    #生产者们
    p1=Process(target=producer,args=('ccc',q))
    p2=Process(target=producer,args=('bbb',q))
  
   
    #消费者们
    c1=Process(target=consumer,args=('ccc',q))
    c2=Process(target=consumer,args=('xxx',q))
    c3=Process(target=consumer,args=('yyy',q))
    
    c1.daemon=True
    c2.daemon=True
    c3.daemon=True
    
    p1.start()
    p2.start()
 
   
    
    c1.start()
    c2.start()
    c3.start()
    
    p1.join()
    p2.join()
    
    #这里之上保证放完了
    q.join() #等着对列结束  即已经放完了 等着取完

    #在这里消费者就没有必要存在了 因为已经取完了 ，所以将消费者设为守护进程
    
    print('主进程')
    
 结果：

厨师[bbb]生产了<包子0>
厨师[ccc]生产了<包子0>
吃货[ccc]吃了<包子0>
厨师[bbb]生产了<包子1>
厨师[ccc]生产了<包子1>
吃货[yyy]吃了<包子1>
吃货[xxx]吃了<包子0>
吃货[ccc]吃了<包子1>
主进程