multiprocessing模块支持的进程间通信主要有两种：管道和队列。一般来说，发送较少的大对象比发送大量的小对象要好。
Queue队列
底层使用管道和锁，同时运行支持线程讲队列中的数据传输到底层管道中，来实习进程间通信。
语法：
Queue([maxsize])
创建共享队列。使用multiprocessing模块的Queue实现多进程之间的数据传递。Queue本身是一个消息队列，
maxsize是队列运行的最大项数，如果不指定，则不限制大小。常用方法
q.close()：关闭队列，不再向队列中添加数据，那些已经进入队列的数据会继续处理。q被回收时将自动调用此方法。
q.empty():如果调用此方法时，队列为null返回True，单由于此时其他进程或者线程正在添加或删除项，
所以结果不可靠，而且有些平台运行该方法会直接报错，我的mac系统运行该方法，直接报错。
q.full():如果调用此方法时，队列已满，返回True，同q.empty()方法，结果不可靠。
q.get([block,timeout])：返回q中的一个项，block如果设置为True,如果q队列为空，该方法会阻塞（就是不往下运行了，处于等待状态），
直到队列中有项可用为止，如果同时页设置了timeout，那么在改时间间隔内，都没有等到有用的项，就会引发Queue.Empty异常。
如果block设置为false，timeout没有意义，如果队列为空，将引发Queue.Empt异常。
q.get_nowait():等同于q.get(False)
q.put(item,block,timeout):将item放入队列，如果此时队列已满：
如果block=True，timeout没有设置，就会阻塞，直到有可用空间为止。
如果block=True，timeout也设置，就会阻塞到timeout，超过这个时间会报Queue.Full异常。
如果block=False，timeout设置无效，直接报Queue.Full异常。
q.put_nowait(item):等同于q.put(item,False)
q.qsize():返回当前队列项的数量，结果不可靠，而且mac会直接报错：NotImplementedError。实例1：验证：put方法会阻塞
实例：
#验证：put方法会阻塞
from multiprocessing import Queue
queue=Queue(3)#初始化一个Queue队列，可以接受3个消息
queue.put("我是第1条信息")
queue.put("我是第2条信息")
queue.put("我是第3条信息")
print("插入第4条信息之前")
queue.put("我是第4条信息")
print("插入第4条信息之后")效果：程序会一直阻塞，最后一句输永远也不会输出。
实例2：closse方法、get方法、put方法简单使用：多进程访问同一个Queue
代码：
#closse方法、get方法、put方法简单使用：多进程访问同一个Queue
from multiprocessing import Queue,Process
import time,os
#参数q就是Queue实例
def mark(q,interval):
time.sleep(interval)
# 打印信息
print("进程%d取出数据："%os.getpid()+queue.get(True))
if __name__=="__main__":
queue = Queue(3) # 初始化一个Queue队列，可以接受3个消息
queue.put("我是第1条信息")
queue.put("我是第2条信息")
queue.put("我是第3条信息")
p1=Process(target=mark,args=(queue,1))
p2=Process(target=mark,args=(queue,2))
p3=Process(target=mark,args=(queue,3))
p1.start()
p2.start()
p3.start()
# 关闭队列，不再插入信息
queue.close()
# 下面插入会导致异常
# queue.put("我是第4条信息")
# 打印第1条信息
print("程序语句执行完成")效果
JoinableQueue队列
创建可连接的共享进程队列，可以看做还是一个Queue，只不过这个Queue除了Queue特有功能外，允许项的消费者通知项的生产者，项已经处理成功。该通知进程时使用共享的信号和条件变量来实现的。
JoinableQueue实例除了与Queue对象相同的方法外，还具有下列方法：
q.task_done():消费者使用此方法发送信号，表示q.get()返回的项已经被处理。
注意⚠️：如果调用此方法的次数大于队列中删除的项的数量，将引发ValueError异常。
q.join():生产者使用此方法进行阻塞，直到队列中所有的项都被处理完成，即阻塞将持续到队列中的每一项均调用q.task_done()方法为止。代码实例：
#利用JoinableQueue实现生产者与消费者，并且加入了哨兵，来监听生产者的要求
from multiprocessing import JoinableQueue,Process
import time
#参数q为JoinableQueue队列实例
def mark(q):
#循环接受信息,一直运行，这也下面为什么要将它设为后台进程的原因，必须保证当主线程退出时，它可以退出
while True:
value = q.get()
print(value) # 实际开发过程中，此处一般用来进行有用的处理
# 消费者发送信号：任务完成（此处实例的任务就是打印一下下）
q.task_done()
#我来方便看出效果，特意停留1s
time.sleep(1)
#使用哨兵，监听生产者的消息，此处通过判断value是否为None来判断传递的消息
if value==None:
#执行哨兵计划后，后面的语句都不会输出
break
if __name__=="__main__":
#实例化JoinableQueue
q=JoinableQueue()
#定义消费者进程
p=Process(target=mark,args=(q,))
#将消费者线程设置为后台进程，随创建它的进程（此处是主进程）的终止而终止
#也就是当它的创建进程（此处是主现场）意外退出时，它也会跟随一起退出。
#并且后台进程无法创建新的进程
p.daemon=True
#启动消费者进程
p.start()
#模拟生产者，生产多个项
for xx in range(5):
print(xx)
#当xx==3时去执行哨兵计划
if xx==3:
print("我用哨兵计划了")
q.put(None)
print("哨兵计完美执行")
q.put("第%d条消息"%xx)
#等待所有项都处理完成再退出，由于使用了哨兵计划，队列没有完全执行，所以会一直卡在这个位置
q.join()
print("程序真正退出了")效果：
管道
除了使用队列来进行进程间通信，还可以使用管道来进行消息传递。
语法：
(connection1,connection2)=Pipe([duplex])
在进程间创建一条管道，并返回元祖(connection1,connection2),其中connection1、connection2表示两端的Connection对象。
默认情况下，duplex=True，此时管道是双向的，如果设置duplex=false，connection1只能用于接收，connection2只能用于发送。
注意：必须在多进程创建之前创建管道。常用方法：
connection.close() :关闭连接，当connection被垃圾回收时，默认会调用该方法。
connection.fileno() :返回连接使用的整数文件描述符
connection.poll([timeout]):如果连接上的数据可用，返回True，timeout为等待的最长时间，如果不指定，该方法将立刻返回结果。
如果指定为None，该方法将会无限等待直到数据到达。
connection.send(obj):通过连接发送对象，obj是与序列号兼容的任意对象。
connection.send_bytes(buffer[,offset,size]):通过连接发送字节数据缓冲区，buffer是支持缓冲区的任何对象。
offset是缓冲区的字节偏移量，而size是要发送的字节数。
connection.recv():接收connection.send()方法返回的对象。如果连接的另一端已经关闭，再也不会存在任何数据，
该方法将引起EOFError异常。
connection.recv_bytes([maxlength]):接收connection.send_bytes()方法发送的一条完整字节信息，maxlength为可以接受的
最大字节数。如果消息超过这个最大数，将引发IOError异常，并且在连接上无法进一步读取。如果连接的另一端已经关闭，
再也不会有任何数据，该方法将引发EOFError异常。
connection.recv_bytes_into(buffer[,offset]):接收一条完整的字节信息，兵把它保存在buffer对象中，
该对象支持可写入的缓冲区接口（就是bytearray对象或类似对象）。
offset指定缓冲区放置消息的字节偏移量。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。实例1：理解管道的生产者与消费者
示意图：
代码：
#理解管道的生产者与消费者
from multiprocessing import Pipe, Process
import time
def mark(pipe):
#接受参数
output_p, input_p = pipe
print("mark方法内部调用input_p.close()")
#消费者（子进程）此实例只接收，所以把输入关闭
input_p.close()
while True:
try:
item = output_p.recv()
except EOFError:
print("报错了")
break
print(item)
time.sleep(1)
print("mark执行完成")
if __name__ == "__main__":
#必须在多进程创建之前，创建管道,该管道是双向的
(output_p, input_p) = Pipe()#创建管道
#创建一个进程，并把管道两端都作为参数传递过去
p = Process(target=mark, args=((output_p, input_p),))
#启动进程
p.start()
#生产者（主进程）此实例只输入，所以关闭输出（接收端）
output_p.close()
for item in list(range(5)):
input_p.send(item)
print("主方法内部调用input_p.close()()")
#关闭生产者（主进程）的输入端
input_p.close()效果图：
实例2：利用管道实现多进程协作：子线程计算结果，返回给主线程
代码：
#利用管道实现多进程协作：子线程计算结果，返回给主线程
from multiprocessing import Pipe, Process
def mark(pipe):
#接受参数
server_p, client_p = pipe
#消费者（子进程）此实例只接收，所以把输入关闭
client_p.close()
while True:
try:
x,y = server_p.recv()
except EOFError:
print("报错了")
break
result=x+y
server_p.send(result)
print("mark执行完成")
if __name__ == "__main__":
#必须在多进程创建之前，创建管道,该管道是双向的
(server_p, client_p) = Pipe()#创建管道
#创建一个进程，并把管道两端都作为参数传递过去
p = Process(target=mark, args=((server_p, client_p),))
#启动进程
p.start()
#生产者（主进程）此实例只输入，所以关闭输出（接收端）
server_p.close()
#发送数据
client_p.send((4,5))
#打印接受到的数据
print(client_p.recv())
client_p.send(("Mark", "大帅哥"))
# 打印接受到的数据
print(client_p.recv())
#关闭生产者（主进程）的输入端
client_p.close()结果：
9
Mark大帅哥
报错了
mark执行完成本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
