进程间通信(队列、管道)、消费者模型和进程池(apply,apply_async,map)

一、队列(先进先出)
进程间通信：IPC(Inter-Process Communication)

队列是使用管道和锁定实现，所以Queue是多进程安全的队列，使用Queue可以实现多进程之间的数据传递。 

1、Queue([maxsize])
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。

Queue的实例q具有以下方法：
q.get( [ block [ ,timeout ] ] )
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True阻塞. 如果设置为False，抛出queue.Empty异常（定义在queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发queue.Empty异常。

q.get_nowait( )
相当于q.get(False)方法，没有取到值也不会阻塞，直接抛出queue.Empty异常。

q.put(item [, block [,timeout ] ] )
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True阻塞。如果设置为False，将引发queue.Full异常（定义在queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发queue.Full异常。

q.put_nowait()
相当于q.put(item,False)方法，队列已满,不会阻塞，直接抛出queue.Full异常。

q.qsize()
返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。

q.empty()
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

q.full()
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。

其他方法(不常用)：
q.close()
关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。

q.cancel_join_thread()
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread()
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。

2、方法使用例子：
from multiprocessing import Queue
import queue

(1)
q = Queue(2)
q.put(1)
q.put(2)

print(q.get())   #
print(q.get())   #

(2)
q = Queue(2)
q.put(1)
q.put(2)
q.put(3)   # 一直阻塞在这里

print(q.get())
print(q.get()) 

(3)
q = Queue(2)
q.put(1)
q.put(2)

print(q.get())   #
print(q.get())   #
print(q.get())   # 一直阻塞在这里

(4)
q = Queue(2)
q.put(1)
q.put(2)
q.put_nowait(3)   # 异常：queue.Full
# q.put(3,False)  # 异常：queue.Full
# q.put(3,timeout=2)  # 2秒后异常：queue.Full

(5)
q = Queue(2)
q.put(1)
q.put(2)

print(q.get())  #
print(q.get())  #
print(q.get_nowait())   # 异常：queue.Empty
# print(q.get(False))   # 异常：queue.Empty
# print(q.get(timeout=2))   # 2秒后异常：queue.Empty

3、小例子
from multiprocessing import Process,Queue

def consume(q):
    print('子进程：',q.get())
    q.put('hi')

if __name__ == '__main__':
    q = Queue()
    p = Process(target=consume,args=(q,))
    p.start()
    q.put('hello')
    p.join()
    print('主进程：',q.get())

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

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

import time
import random
from multiprocessing import Process,Queue

def consumer(q,name):
    # 消费者
    while True:
        food = q.get()  # 在队列中取值
        if food is None:break
        time.sleep(random.uniform(0.3,1))  # 模拟吃消耗的时间
        print('%s偷吃了%s，快打死他' %(name,food))

def producter(q,name,food):
    # 生产者
    for i in range(10):
        time.sleep(random.uniform(0.5,0.9))  # 模拟生产时间
        print('%s生产了%s，序号：%s' %(name,food,i))
        q.put(food+str(i))  # 把值存入队列中

if __name__ == '__main__':
    q = Queue()  # Queue队列对象
    c1 = Process(target=consumer,args=(q,'小明'))
    c2 = Process(target=consumer,args=(q,'小东'))
    c1.start()
    c2.start()

    p1 = Process(target=producter,args=(q,'张三','面包'))
    p2 = Process(target=producter,args=(q,'李四','可乐'))
    p1.start()
    p2.start()

    p1.join()
    p2.join()

    q.put(None) # 有几个consumer进程就需要放几个None,表示生产完毕(这就有点low了)
    q.put(None)

二、JoinableQueue
JoinableQueue和Queue几乎一样，不同的是JoinableQueue队列允许使用者告诉队列某个数据已经处理了。通知进程是使用共享的信号和条件变量来实现的。
task_done()：使用者使用此方法发出信号，表示q.get()返回的项目已经被处理
join()：当队列中有数据的时候，使用此方法会进入阻塞，直到放入队列中所有的数据都被处理掉(都被task_done)才转换成不阻塞

解决刚才生产者消费者模型low的问题：
import time
import random
from multiprocessing import Process,JoinableQueue

def consumer(jq,name):
    # 消费者
    while True:
        food = jq.get()  # 在队列中取值
        # if food is None:break
        time.sleep(random.uniform(0.3,1))  # 模拟吃消耗的时间
        print('%s偷吃了%s，快打死他' %(name,food))
        jq.task_done() # 向jq.join()发送一次信号,证明这个数据已经处理了

def producter(jq,name,food):
    # 生产者
    for i in range(10):
        time.sleep(random.uniform(0.5,0.9))  # 模拟生产时间
        print('%s生产了%s，序号：%s' %(name,food,i))
        jq.put(food+str(i))  # 把值存入队列中

if __name__ == '__main__':
    jq = JoinableQueue()
    c1 = Process(target=consumer,args=(jq,'小明'))
    c2 = Process(target=consumer,args=(jq,'小东'))

    c1.daemon = True  # 把消费者设置为守护进程
    c2.daemon = True

    c1.start()
    c2.start()

    p1 = Process(target=producter,args=(jq,'张三','面包'))
    p2 = Process(target=producter,args=(jq,'李四','可乐'))
    p1.start()
    p2.start()

    p1.join()
    p2.join()

    jq.join()   # 数据全部被task_done后才不阻塞

三、管道
#创建管道的类：
Pipe([duplex]):在进程之间创建一条管道，并返回元组（left,right）,其中left,right表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道

#参数介绍：
duplex:默认管道是全双工的，如果将duplex改成False，left只能用于接收，right只能用于发送。

#主要方法：
    right.recv():接收left.send()发送的内容。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
    letf.send():通过连接发送内容。

#其他方法：
close():关闭连接。
fileno():返回连接使用的整数文件描述符
poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout设置成None，操作将无限期地等待数据到达。

recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    

recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

注意：
# 队列是基于管道实现的，使用管道 + 锁的模式形成的IPC方式，使得进程之间数据安全
# 管道是基于socket实现的，使用socket + pickle 的模式形成的IPC方式，使得进程之间数据是不安全的且存取数据复杂(同一时间不同进程对同一个数据进行处理，造成数据的不安全)

例子：(左边发送，右边接收)
from multiprocessing import Process,Pipe

def test(right):
    print(right.recv())
    right.close()

if __name__ == '__main__':
    left,right = Pipe()
    p = Process(target=test,args=(right,))
    p.start()
    left.send('hello')

(右边发送，左边接收)
from multiprocessing import Process,Pipe

def test(left):
    left.send('hi')
    left.close()

if __name__ == '__main__':
    left,right = Pipe()
    p = Process(target=test,args=(left,))
    p.start()
    print(right.recv())

# pipe的端口管理不会随着某一个进程的关闭就关闭
# 操作系统来管理进程对这些端口的使用，不使用的端口应该关闭它
# 一条管道，两个进程，就有4个端口  每关闭一个端口计数-1，直到只剩下一个端口的时候 recv就会报错
# 如果不关闭不使用的端口，在已经把数据发送完毕的情况下，那么接收端的recv就会一直挂起，等待接收数据，这个进程就一直不能关闭
# 因此不使用的端口就应该关闭它，让recv抛出异常后对这个进程进行处理

from multiprocessing import Process,Pipe
def consumer(left,right):
    left.close()  # 若这里不close，则不会异常EOFError，数据接收完毕后，下面的right.recv()就会一直挂起
    while True:
        try:
            print(right.recv())
        except EOFError:
            break

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


四、进程池(不能传队列作为子进程的参数，只能传管道)
1、为什么要有进程池?
在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？
首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。

2、进程池的概念
定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。
如果有很多任务需要执行，池中的进程数量不够，任务就要等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。
这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。

# 信号量
    # 500件衣服          有500个任务
    # 500个人           创建了500个进程
    # 只有4台机器        但是只有4个CPU
    # 轮流去做，一个人做完了就走，机器留给另一个人做

# 多进程
    # 500件衣服          有500个任务
    # 500个人           创建了500个进程
    # 抢4台机器          但是只有4个CPU
    # 大家抢着机器去做，抢到的就做

# 进程池
    # 500件衣服          有500个任务
    # 4个人             创建了4个进程
    # 4台机器           有4个CUP
    # 4个人拿着机器做，做完一个继续做下一个，直到500个做完

3、创建进程池
p = Pool([numprocess  [,initializer [, initargs]]])

参数介绍：
numprocess:要创建的进程数，如果省略，将默认使用os.cpu_count()的值,即你电脑CPU的个数
initializer：是每个工作进程启动时要执行的可调用对象，默认为None
initargs：是要传给initializer的参数组

主要方法：
同步提交 p.apply(func [, args [, kwargs]])
    返回值 ： 子进程对应函数的返回值(子进程return的返回值)
    一个一个顺序执行的，并没有任何并发效果

异步提交 p.apply_async(func [, args [, kwargs]])
    没有返回值，要想所有任务能够顺利的执行完毕，需要执行：
        p.close()
        p.join()  # 必须先close再join，阻塞直到进程池中的所有任务都执行完毕
    有返回值(res接收返回值)的情况下
        res.get()  # get不能在提交任务之后立刻执行，应该是先提交所有的任务再通过get获取结果

p.map()
    异步提交的简化版本
    自带close和join方法

p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成

p.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

其他方法(不常用)
方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():如果调用完成，返回True
obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

4、例子
4-1、apply
import os
import time
from multiprocessing import Pool

def test(num):
    time.sleep(1)
    print('%s:%s' %(num,os.getpid()))
    return num*2

if __name__ == '__main__':
    p = Pool()
    for i in range(20):
        res = p.apply(test,args=(i,)) # 提交任务的方法 同步提交
        print('-->',res)  # res就是test的return的值

4-2、apply_async
import time
from multiprocessing import Pool

def func(num):
    time.sleep(1)
    print('做了%s件衣服'%num)

if __name__ == '__main__':
    p = Pool(4)  # 进程池中创建4个进程，不写的话，默认值为你电脑的CUP数量
    for i in range(50):
        p.apply_async(func,args=(i,)) # 异步提交func到一个子进程中执行，没有返回值的情况
    p.close() # 关闭进程池，用户不能再向这个池中提交任务了
    p.join()  # 阻塞，直到进程池中所有的任务都被执行完

注意：
异步提交且没有返回值接收的情况下必须要用close()和join()
因为如果没有close()和join()，主进程执行完毕后会立刻把子进程回收了，相当于子进程还没来得及开启
所以要join，让子进程结束后再结束父进程，但是进程池中要使用join就必须先进行close

import time
import os
from multiprocessing import Pool

def test(num):
    time.sleep(1)
    print('%s:%s' %(num,os.getpid()))
    return num*2

if __name__ == '__main__':
    p = Pool()
    res_lst = []
    for i in range(20):
        res = p.apply_async(test,args=(i,))   # 提交任务的方法 异步提交
        res_lst.append(res)
    for res in res_lst:
        print(res.get())

注意：
异步提交有返回值的情况下，res是一个对象代表的是这个任务的编号，需要用res.get()方法让任务执行且把返回值返回给你。
get有阻塞效果，拿到子进程的返回值后才不阻塞，所以并不需要再使用close和join。

4-3、map
import time
import os
from multiprocessing import Pool

def test(num):
    time.sleep(1)
    print('%s:%s'%(num,os.getpid()))
    return num*2

if __name__ == '__main__':
    p = Pool()
    p.map(test,range(20))

注意：
map接收一个函数和一个可迭代对象，是异步提交的简化版本，自带close和join方法
可迭代对象的每一个值就是函数接收的实参，可迭代对象的长度就是创建的任务数量
map拿到返回值是所有结果组成的列表

import time
from multiprocessing import Pool

def func(num):
    print('子进程：',num)
    # time.sleep(1)
    return num

if __name__ == '__main__':
    p = Pool()
    ret = p.map(func,range(10))   # ret是列表
    for i in ret:
        print('返回值：',i)