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

摘要：上一篇文章进程专题进程池下一篇文章进程专题共享数据与同步模块支持的进程间通信主要有两种管道和队列。队列底层使用管道和锁，同时运行支持线程讲队列中的数据传输到底层管道中，来实习进程间通信。

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

multiprocessing模块支持的进程间通信主要有两种：管道和队列。一般来说，发送较少的大对象比发送大量的小对象要好。

底层使用管道和锁，同时运行支持线程讲队列中的数据传输到底层管道中，来实习进程间通信。

语法：

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("程序语句执行完成")

效果

创建可连接的共享进程队列，可以看做还是一个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执行完成