Python进程专题5：进程间通信

上一篇文章：Python进程专题4：进程池Pool
下一篇文章：Python进程专题6：共享数据与同步

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执行完成