引言

前面已经介绍了进程间通信（IPC）的相关内容，也简单列举了常用的IPC机制。虽然进程间通信与线程间通信在底层实现上会有很大的区别，但是，只要准确把握进程数据隔离的特性，就能更加轻易理解相关IPC组件的使用。

本文打算介绍基于Pipe组件的进程间通信，本文的主要内容有：

1、Pipe的常用操作方法

2、Pipe的特性

3、Pipe的适用场景

Pipe的常用操作方法

管道Pipe是multiprocessing模块中的一个组件，可以通过该组件快速实现两个进程间的双向通信。

通过代码来简单看下Pipe的常用操作方法：

from multiprocessing import Pipe, Process
import time


def send(conn):
    for msg in ('你好', '你吃过饭了吗', '今天天气真好', 'Bye'):
        print(f'A发送: {msg}')
        conn.send(f'{msg}')
        time.sleep(1)
    conn.close()


def receive(conn):
    while True:
        msg = conn.recv()
        print(f'B接收到: {msg}')
        if msg == 'Bye':
            break
    conn.close()


if __name__ == '__main__':
    send_conn, recv_conn = Pipe()[0]
    print(type(Pipe))
    sender = Process(target=send, args=(send_conn,))
    receiver = Process(target=receive, args=(recv_conn,))
    sender.start()
    receiver.start()
    sender.join()
    receiver.join()

执行结果：

通过上述代码可以看到Pipe的使用步骤如下：

1、通过Pipe()函数创建一个管道，会返回一个包含两个连接对象的元组，可以类比Linux中的文件描述符，用于进程对管道进行操作。

2、需要向管道发送数据的进程，可以通过连接对象的send()方法。

3、需要从管道接收数据的进程，可以通过连接对象的recv()方法。

Pipe的特性

Pipe的使用虽然非常简单，但是，如果不了解其主要特性，也可能在使用中遇到问题。其主要的特性有：

1、两个进程通信：不同于Queue等IPC机制，Pipe只能用于两个进程进行通信。

2、双向通信：允许两个进程进行数据的双向传输，每个连接对象都可以发送和接收数据。

3、适用于小量数据：适合传输小量数据，性能优于Queue。

4、阻塞原语：调用recv()方法时，如果管道中没有数据，会一直阻塞，直到有进程向管道发送数据。

Pipe的适用场景

Pipe简单易用的双向、小量数据传输，有如下几个适用场景：

1、简单、快速的双向通信

2、任务之间需要频繁的命令和响应

3、进程间需要定期进行进度、状态的交换

4、实时数据处理的场景

下面通过代码分别模拟下状态同步和命令-响应的场景。

模拟场景1：任务状态同步

from multiprocessing import Pipe, Process
import time


def long_task(conn):
    for i in range(10):
        # 通过等待模拟任务运行
        time.sleep(1)
        conn.send(f'任务执行进度：{i + 1} / 10')
    conn.send(f'任务执行完成！')
    conn.send('finish')
    conn.close()


if __name__ == '__main__':
    send_conn, recv_conn = Pipe()
    worker = Process(target=long_task, args=(send_conn,))
    worker.start()
    while True:
        msg = recv_conn.recv()
        if msg == 'finish':
            break
        print(msg)
    worker.join()

运行结果：

模拟场景2：命令-响应

from multiprocessing import Pipe, Process
import time


def work(conn):
    while True:
        cmd = conn.recv()
        if cmd == 'exit':
            print('好的，我回家吃饭了')
            break
        if cmd == 'turn left':
            print('已完成向左转')
        if cmd == 'turn right':
            print('已完成向右转')
        if cmd == 'run':
            print('跑起来了')


if __name__ == '__main__':
    send_conn, recv_conn = Pipe()
    worker = Process(target=work, args=(recv_conn,))
    worker.start()
    for cmd in ('turn left', 'run', 'turn right', 'exit'):
        send_conn.send(cmd)
        time.sleep(1)
    worker.join()

运行结果：

以上两个案例代码比较简单，这里就不对代码进行展开说明了。

其实，通过管道Pipe进行进程间的通信，很多时候更适合简单的通信协议的设计。可以类似的理解为主进程负责响应用户的操作，并将响应操作转换为指令，发送给管道。子进程用于从管道中接收指令，并真正完成对应的任务逻辑。

总结

本文简单介绍了Python中Pipe的使用，Pipe两个进程间进行简单、小量数据的双向传递等相关特性，使得Pipe很适合两个进程的状态同步、命令-响应等场景的需求实现，代码编写起来，也特别简单、易读。

以上就是本文的全部内容，感谢拨冗阅读！