（一）引入

• 借助于消息队列，进程可以将消息放入队列中，然后由另一个进程从队列中取出。
• 这种通信方式是非阻塞的，即发送进程不需要等待接收进程的响应即可继续执行。
• multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
• 进程间通信（IPC）方式二：管道（不推荐使用，了解即可）

（二）介绍

（1）创建管道的类

• Pipe[duplex]
  • 在进程之间创建一条管道，并返回元组（conn1,conn2），其中conn1，conn2表示管道两端的连接对象
  • 强调一点：必须在产生Process对象之前产生管道

（2）参数介绍

• duplex
  • 默认管道时全双工的，如果将duplex设成False，conn1只能用于接收，conn2只能用于发送

（3）主要方法

• conn1.recv()
  • 接收conn2.send(obj)发送的对象
  • 如果没有消息可接收，recv方法会一直阻塞
  • 如果连接的另外一端已经关闭，那么recv（）方法会爆出error
• conn1.send(obj)
  • 通过连接发送对象，obj是与序列化兼容的任意对象

（4）次要方法

• conn1.close()
  • 关闭连接。如果conn1被垃圾回收，将自动调用此方法
• conn1.fileno()
  • 返回连接使用的整数文件描述符
• conn1.poll([timeout])
  • 如果连接上的数据可用，返回True。
  • timeout指定等待的最长时限。
  • 如果省略此参数，方法将立即返回结果。
  • 如果将timeout射成None，操作将无限期地等待数据到达。
• conn1.recv_bytes([maxlength])
  • 接收c.send_bytes()方法发送的一条完整的字节消息。
  • maxlength指定要接收的最大字节数。
  • 如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。
  • 如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
• conn.send_bytes(buffer [, offset [, size]])
  • 通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。
  • 结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收
• conn1.recv_bytes_into(buffer [, offset]):
  • 接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。
  • offset指定缓冲区中放置消息处的字节位移。
  • 返回值是收到的字节数。
  • 如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。
  • 基于管道实现进程间通信（与队列的方式是类似的，队列就是管道加锁实现的）

（三）代码实现

（1）基于管道实现进程间通信

# 导入模块
from multiprocessing import Process,Pipe

def producer(conn):
    left_conn, right_conn=conn
    # 右管道关闭
    right_conn.close()
    # 左边管道传入数据
    for i in range(1,6):
        left_conn.send(i)
    # 传入数据结束,左管道关闭
    left_conn.close()
def customer(conn):
    # 接收管道
    left_conn, right_conn=conn
    # 左管道关闭
    left_conn.close()
    # 右管道接收信息
    while True :
        try:
            msg=right_conn.recv()
            print(msg)
        except Exception as e:
            right_conn.close()
            break
def main():
    # 定义管道
    left_conn,right_conn=Pipe()
    # 创建子进程
    custom=Process(target=customer,args=((left_conn,right_conn),))
    # 启动子进程
    custom.start()
    # 生产者生产数据
    producer((left_conn,right_conn))
    # 关闭右管道
    right_conn.close()
    # 关闭左管道
    left_conn.close()
    # 子进程等待主进程结束
    custom.join()
    print("结束")

if __name__ == '__main__':
    main()
# 1
# 2
# 3
# 4
# 5
# 结束

（2）特别注意

• 生产者和消费者都么有使用管道的某个端点，就应该将其关闭
• 如果生产者中关闭管道的右端，在消费者中关闭管道的左边
• 如果我姐执行这些步骤了，程序可能在消费者中的recv（）早走上挂起
• 管道是由操作系统进行引用计数的,必须在所有进程中关闭管道后才能生产EOFError异常。
• 因此在生产者中关闭管道不会有任何效果，付费消费者中也关闭了相同的管道端点。

（3）管道编写与进程交互

• 管道可以用于双向通信，利用通常在客户端/服务器中使用的请求／响应模型或远程过程调用，就可以使用管道编写与进程交互的程序

# 导入模块
from multiprocessing import Process,Pipe

def addr(p):
    # 获取到两个管道对象
    server,client=p
    #将客户端关闭
    client.close()
    while True:
        try:
            # 将接收到的数据解包
            x,y=server.recv()
        except Exception as e:
            # 无则关闭服务端
            server.close()
            break
        res=x+y
        server.send(res)
    print('server done')


def main():
    # 创建管道对象
    server,client=Pipe()
    # 创建一个子进程
    p=Process(target=addr,args=((server,client),))
    # 启动子进程
    p.start()
    # 关闭服务端
    server.close()
    # 从客户端传输数据
    client.send((10,20))
    # 查看客户端接收到的数据
    print(client.recv())
    # 关闭客户端
    client.close()

    # 等待子进程结束
    p.join()
    print("结束")
if __name__ == '__main__':
    main()

# 30
# server done
# 结束