【4.5】进程间通信(管道)

【一】引入

• 借助于消息队列，进程可以将消息放入队列中，然后由另一个进程从队列中取出。

• 这种通信方式是非阻塞的，即发送进程不需要等待接收进程的响应即可继续执行。

• multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的

• 进程间通信（IPC）方式二：管道（不推荐使用，了解即可）

【二】介绍

（1）创建管道的类

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

（2）参数介绍

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

（3）主要方法

• conn1.recv()
  • 接收conn2.send(obj)发送的对象。
  • 如果没有消息可接收，recv方法会一直阻塞。
  • 如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
• 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 consumer(p_conn, name):
    # 【1】获取到两个管道对象
    left_conn, right_conn = p_conn
    # 【2】关闭左侧管道
    left_conn.close()
    while True:
        try:
            # 【3】从右侧管道取数据
            baozi = right_conn.recv()
            print('%s 收到包子:%s' % (name, baozi))
        except EOFError:
            right_conn.close()
            break


def producer(seq, p_conn):
    # 【1】获取到创建的两个管道对象
    left_conn, right_conn = p_conn
    # 【2】关闭右管道
    right_conn.close()
    # 【3】向左管道送数据
    for i in seq:
        left_conn.send(i)
        # time.sleep(1)
    else:
        # 送完关闭
        left_conn.close()


if __name__ == '__main__':
    # 【一】默认创建的管道是双通道的
    # 【二】创建管道必须在创建子进程之前
    left_conn, right_conn = Pipe()
    # 【三】创建子进程
    custom = Process(target=consumer, args=((left_conn, right_conn), 'c1'))
    # 【四】启动子进程
    custom.start()
    # 【五】产生数据
    seq = (i for i in range(10))
    # 【六】生产者生产数据
    producer(seq, (left_conn, right_conn))
    # 【七】右管道关闭
    right_conn.close()
    # 【八】左管道关闭
    left_conn.close()
    # 【九】子进程等待主进程结束
    custom.join()
    print('主进程')
    
    # c1 收到包子:0
    # c1 收到包子:1
    # c1 收到包子:2
    # c1 收到包子:3
    # c1 收到包子:4
    # c1 收到包子:5
    # c1 收到包子:6
    # c1 收到包子:7
    # c1 收到包子:8
    # c1 收到包子:9
    # 主进程

【2】管道通信特别注意

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

【3】管道编写进程交互

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

from multiprocessing import Process, Pipe


def adder(p, name):
    # 【1】获取到两个管道对象
    server, client = p
    # 【2】将客户端关闭
    client.close()
    # 【3】轮转接受数据
    while True:
        try:
            # 【4】将接收到的数据解包
            x, y = server.recv()
        except EOFError:
            # 【5】无则关闭服务端
            server.close()
            break
        # 【4】 记录读取到的所有内容
        res = x + y
        # 【5】将处理好的数据从服务端返回给客户端
        server.send(res)
    print('server done')


if __name__ == '__main__':
    # 【一】创建两个管道对象
    server, client = Pipe()
    # 【二】创建一个子进程
    c1 = Process(target=adder, args=((server, client), 'c1'))
    # 【三】启动子进程
    c1.start()
    # 【四】关闭服务端
    server.close()
    # 【五】从客户端传输数据
    client.send((10, 20))
    # 【六】查看客户端接收到的数据
    print(client.recv())
    # 【七】关闭客户端
    client.close()

    # 等待子进程结束
    c1.join()
    print('主进程')

# 注意：send()和recv()方法使用pickle模块对对象进行序列化。

# 30
# server done
# 主进程