进程-队列,管道,数据共享,进程池

import time
import random
from multiprocessing import JoinableQueue,Process
# join  阻塞
def consumer(q,name):
    while True:
        food = q.get()
        print('%s 吃了 %s'%(name,food))
        time.sleep(random.random())
        q.task_done()

def producer(q,name,food,n=10):
    for i in range(n):
        time.sleep(random.random())
        fd = food+str(i)
        print('%s 生产了 %s'%(name,fd))
        q.put(fd)
    q.join()

if __name__ == '__main__':
    q = JoinableQueue()
    c1 = Process(target=consumer,args=(q,'alex'))
    c1.daemon = True
    c1.start()
    c2 = Process(target=consumer, args=(q, 'alex'))
    c2.daemon = True
    c2.start()
    p1 = Process(target=producer,args=(q,'太白','泔水'))
    p1.start()
    p2 = Process(target=producer, args=(q, 'egon', '鱼刺'))
    p2.start()
    p1.join()
    p2.join()

只有multiprocessing中的队列 才能帮助你 实现 IPC
永远不可能出现数据不安全的情况,多个进程不会同时取走同一个数据
提供给你的方法
    put
    get
    put_nowait
    get_nowait
    empty   - 在多进程内不可靠
    full    - 在多进程内不可靠
    qsize   - 在多进程内不可靠

由于先进先出的特点+进程通信的功能+数据进程安全,经常用它来完成进程之间的通信
生产者消费者模型
    生产者和消费者的效率平衡的问题
    内存的控制 - 队列的长度限制
    让消费者自动停下来

JoinableQueue
    在消费数据的时候 task_done
    在生产端\主进程 join


二 管道
队列就是基于管道实现的
队列 数据安全的
管道 数据不安全的
队列 = 管道 + 锁

from multiprocessing import Pipe
left,right = Pipe()
left.send('aaa')
print(right.recv())

from multiprocessing import Pipe,Process
def consumer(left,right):
    left.close()
    while True:
        try:
            print(right.recv())
        except EOFError:
            break

if __name__ == '__main__':
    left,right = Pipe()
    p = Process(target=consumer,args=(left,right))
    p.start()
    right.close()
    for i in range(10):
        left.send('hello')
    left.close()

 EOF异常的触发
在这一个进程中 如果不在用这个端点了,应该close
这一在recv的时候,如果其他端点都被关闭了,就能够知道不会在有新的消息传进来
此时就不会在这里阻塞等待,而是抛出一个EOFError
* close并不是关闭了整个管道,而是修改了操作系统对管道端点的引用计数的处理

 

三.数据共享

from multiprocessing import Manager,Process,Lock
def work(d,lock):
    with lock:
        d['count']-=1

if __name__ == '__main__':
    lock = Lock()
    m = Manager()  #开启共享
    dic=m.dict({'count':100})
    p_l=[]
    for i in range(100):
        p=Process(target=work,args=(dic,lock))
        p_l.append(p)
        p.start()
    for p in p_l:
        p.join()
    print(dic)

四.进程池

开启进程慢
几个CPU就能同时运行几个进程 进程的个数不是无限开启的

100个任务
进程池
如果必须用多个进程
    且是高计算型 没有IO 型的程序
    希望并行 最充分的使用CPU

import os
import time
from multiprocessing import Pool
def func(i):
    time.sleep(0.1)
    print(os.getpid(),i)

if __name__ == '__main__':
    p = Pool(5)
    for i in range(20):
        p.apply_async(func,args=(i,))
    p.close()
    p.join()