python多进程之IPC机制以及生产者消费者模型

1.进程间通信(IPC机制)

第一种:管道

import subprocess
res=subprocess.Popen('dir',shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)

第二种:队列=管道+锁

注:队列占用的是内存的大小,不应该放大数据,应该放一些简单的消息

from multiprocessing import Queue
q=Queue()
q.put(['a'],block=True,timeout=3) block默认为True,队列满时锁住,如果三秒之后队列还是满的,会抛出异常
q.put({'a':1},block=True,timeout=3)
q.put('a',block=True,timeout=3)
q.put_nowait(1)等同于q.put(1,block=False) 队列满时直接抛出异常,不会再等
prite(q.get(block=True,timeout=3))从队列中取值,队列中没有值等3秒,之后还没值会抛出异常
prite(q.get_nowait())从队列中取值,如果没有值,直接抛出异常

2.生产者消费者模型

1. 什么是生产者消费者模型
    生产者:代指生产数据的任务
    消费者:代指处理数据的任务
    该模型的工作方式:
        生产生产数据传递消费者处理

        实现方式:
            生产者---->队列<------消费者

2. 为何要用
    当程序中出现明细的两类任务,一类负责生产数据,一类负责处理数据
    就可以引入生产者消费者模型来实现生产者与消费者的解耦合,平衡生产能力与消费能力,从提升效率

3.如何用:
第一种:

from multiprocessing import Queue,Process
import time,random
def Producer(name,food,p):
    for i in range(1,3):
        res='%s%s'%(food,i)
        time.sleep(random.randint(1,3))
        p.put(res)
        print('厨师%s做了<%s>'%(name,res))
def consumer(name,p):
    while True:
        res=p.get()
        if res==None:break     #从队列中去到None时,结束循环
        time.sleep(random.randint(1,3))
        print('大傻逼%s吃了<%s>..............'%(name,res))
if __name__ == '__main__':
    q=Queue()
    p1=Process(target=Producer,args=('lmj','水',q))
    p2=Process(target=Producer,args=('lmj2','包子',q))
    p3=Process(target=Producer,args=('lmj3','汤',q))
    c1=Process(target=consumer,args=('lbz',q))
    c2=Process(target=consumer,args=('lmz',q))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()  #用join方法保证生产者生产完毕
    p2.join()
    p3.join()
    q.put(None) #生产完毕后向队列中丢入两个None,两个消费者拿到之后就会停止
    q.put(None)
    print('master')

import time,random
from multiprocessing import Process,JoinableQueue

def producer(name,food,q):
    for i in range(3):
        res='%s%s' %(food,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() #消费者每取走一个值,就会给q.join发信号取走一个值

if __name__ == '__main__':
    q=JoinableQueue()
    # 生产者们
    p1=Process(target=producer,args=('小','水',q))
    p2=Process(target=producer,args=('中','包子',q))
    p3=Process(target=producer,args=('大','汤',q))
    # 消费者们
    c1=Process(target=consumer,args=('1',q))
    c2=Process(target=consumer,args=('2',q))
    c1.daemon=True  #将消费者设置成主进程的守护进程,主进程一旦结束,消费者也会结束
    c2.daemon=True

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

    p1.join()
    p2.join()
    p3.join()
    q.join() # 此时生产者不会再往队列里面添加东西,统计队列里还剩多少值.主进程等q结束,即q内数据被取干净了
    print('主')

执行结果:
厨师[小]生产了<水0>
厨师[中]生产了<包子0>
厨师[大]生产了<汤0>
厨师[大]生产了<汤1>
吃货[2]吃了<水0>
厨师[小]生产了<水1>
吃货[1]吃了<包子0>
厨师[中]生产了<包子1>
厨师[小]生产了<水2>
厨师[中]生产了<包子2>
吃货[2]吃了<汤0>
厨师[大]生产了<汤2>
吃货[1]吃了<汤1>
吃货[2]吃了<水1>
吃货[1]吃了<包子1>
吃货[2]吃了<水2>
吃货[1]吃了<包子2>
吃货[2]吃了<汤2>
主