python使用multiprocessing多进程通讯

1 使用管道（Pipe）和使用队列（Queue）

在Python中，multiprocessing模块提供了一种简单的方式来利用多核处理器进行并行处理。对于进程间的通信，multiprocessing模块提供了几种机制，其中最常用的是管道（Pipe）和队列（Queue）。下面我将详细介绍这两种方法，并给出相应的示例代码。

2 进行父进程和子进程间的简单通信

1. 使用管道（Pipe）

管道是进程间通信的一种非常直接的方式。它可以实现两个进程之间的双向通信。multiprocessing.Pipe() 函数创建一对连接两端的管道对象。

示例代码

这里有一个使用管道进行进程间通信的例子：

import multiprocessingdef worker(conn):# 从管道接收消息msg = conn.recv()print(f"Received: {msg}")# 向管道发送消息conn.send("Reply from the worker")# 关闭管道conn.close()if __name__ == '__main__':# 创建管道parent_conn, child_conn = multiprocessing.Pipe()# 创建子进程p = multiprocessing.Process(target=worker, args=(child_conn,))# 启动子进程p.start()# 向管道发送消息parent_conn.send("Hello from the main process!")# 从管道接收回复reply = parent_conn.recv()print(f"Received Reply: {reply}")# 等待子进程结束p.join()

在这个例子中：

• 我们首先导入了 multiprocessing 模块。
• 使用 multiprocessing.Pipe() 创建了一个管道，返回两个连接对象 parent_conn 和 child_conn。
• 创建了一个子进程 p，它调用 worker 函数，并传入 child_conn 作为参数。
• 主进程中，我们向管道发送了一条消息 "Hello from the main process!"。
• 子进程中，我们从管道接收了这条消息，并打印出来，然后向管道发送回复。
• 主进程中，我们再次从管道接收回复，并打印出来。
• 最后，我们等待子进程结束。

2. 使用队列（Queue）

队列是一种更安全的进程间通信方式，因为它内置了线程安全的锁机制，可以避免竞态条件。multiprocessing.Queue() 可以创建一个进程安全的队列对象。

示例代码

这里是一个使用队列进行进程间通信的例子：

import multiprocessingdef worker(queue):# 从队列接收消息msg = queue.get()print(f"Received: {msg}")# 向队列发送消息queue.put("Reply from the worker")if __name__ == '__main__':# 创建队列queue = multiprocessing.Queue()# 创建子进程p = multiprocessing.Process(target=worker, args=(queue,))# 启动子进程p.start()# 向队列发送消息queue.put("Hello from the main process!")# 从队列接收回复reply = queue.get()print(f"Received Reply: {reply}")# 等待子进程结束p.join()

在这个例子中：

• 我们同样首先导入了 multiprocessing 模块。
• 使用 multiprocessing.Queue() 创建了一个队列对象。
• 创建了一个子进程 p，它调用 worker 函数，并传入 queue 作为参数。
• 主进程中，我们向队列发送了一条消息 "Hello from the main process!"。
• 子进程中，我们从队列接收了这条消息，并打印出来，然后向队列发送回复。
• 主进程中，我们再次从队列接收回复，并打印出来。
• 最后，我们等待子进程结束。

总结

管道和队列都是有效的进程间通信机制。管道适用于两个进程之间直接通信的情况，而队列则更适合多个进程之间共享数据，尤其是在数据顺序和安全性方面有较高要求的情况下。选择哪种方法取决于你的具体需求和场景。

3 进行多个进程间的简单通信

当然可以！下面我将提供两个简单的例子来展示如何使用 Python 的 multiprocessing 模块进行多个并行进程间的通信。我们将分别使用管道（Pipe）和队列（Queue）来实现这一目标。

示例 1: 使用管道（Pipe）进行多个进程间的简单通信

在这个例子中，我们将创建一个主进程和两个子进程。主进程将发送乘法运算请求给子进程，子进程将计算结果并将其返回给主进程。

示例代码

import multiprocessingdef worker(conn):"""子进程处理函数"""while True:# 从管道接收消息data = conn.recv()if data is None:breaka, b = data# 计算结果result = a * b# 向管道发送结果conn.send(result)if __name__ == '__main__':# 创建管道parent_conns, child_conns = zip(*[multiprocessing.Pipe() for _ in range(2)])# 创建子进程processes = [multiprocessing.Process(target=worker, args=(conn,)) for conn in child_conns]# 启动子进程for p in processes:p.start()# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for i, (a, b) in enumerate(requests):parent_conns[i % len(parent_conns)].send((a, b))# 接收结果results = []for i, parent_conn in enumerate(parent_conns):for _ in range(len(requests) // len(parent_conns)):result = parent_conn.recv()results.append(result)print(f"Result: {result}")# 发送结束信号for parent_conn in parent_conns:parent_conn.send(None)# 等待子进程结束for p in processes:p.join()print("All results:", results)

示例 2: 使用队列（Queue）进行多个进程间的简单通信

在这个例子中，我们将使用队列来进行多个进程间的通信。我们将创建一个主进程和两个子进程。主进程将发送乘法运算请求到队列中，子进程将从队列中取出请求进行计算，并将结果发送回主进程。

示例代码

import multiprocessingdef worker(input_queue, output_queue):"""子进程处理函数"""while True:# 从队列接收消息data = input_queue.get()if data is None:breaka, b = data# 计算结果result = a * b# 向队列发送结果output_queue.put(result)if __name__ == '__main__':# 创建队列input_queue = multiprocessing.Queue()output_queue = multiprocessing.Queue()# 创建子进程processes = [multiprocessing.Process(target=worker, args=(input_queue, output_queue)) for _ in range(2)]# 启动子进程for p in processes:p.start()# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for request in requests:input_queue.put(request)# 接收结果results = []for _ in range(len(requests)):result = output_queue.get()results.append(result)print(f"Result: {result}")# 发送结束信号for _ in range(len(processes)):input_queue.put(None)# 等待子进程结束for p in processes:p.join()print("All results:", results)

解释

示例 1: 使用管道（Pipe）进行多个进程间的简单通信

1. 我们创建了两个双向管道，它们由 parent_conn 和 child_conn 组成。
2. 创建了两个子进程 processes，它们调用 worker 函数，并传入 child_conn 作为参数。
3. 主进程中，我们依次向管道发送乘法请求。
4. 子进程中，我们从管道接收请求，计算结果，并将结果通过管道发回给主进程。
5. 主进程中，我们从管道接收结果，并打印出来。
6. 最后，我们向管道发送 None 作为结束信号，并等待子进程结束。

示例 2: 使用队列（Queue）进行多个进程间的简单通信

1. 我们创建了一个输入队列 input_queue 和一个输出队列 output_queue。
2. 创建了两个子进程 processes，它们调用 worker 函数，并传入两个队列作为参数。
3. 主进程中，我们依次向输入队列发送乘法请求。
4. 子进程中，我们从输入队列接收请求，计算结果，并将结果通过输出队列发回给主进程。
5. 主进程中，我们从输出队列接收结果，并打印出来。
6. 最后，我们向输入队列发送 None 作为结束信号，并等待子进程结束。

总结

这两种方法都可以有效地实现多个进程间的简单通信。使用管道的方式更简单直接，适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信，特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。

4 进程池中的简单通信

当然可以！下面我将提供两个简单的例子来展示如何使用 Python 的 multiprocessing 模块中的 Pool 类进行多个并行进程间的通信。我们将分别使用管道（Pipe）和队列（Queue）来实现这一目标。

示例 1: 使用管道（Pipe）进行进程池中的简单通信

在这个例子中，我们将创建一个主进程和一个进程池。主进程将发送乘法运算请求给进程池中的子进程，子进程将计算结果并将其返回给主进程。

示例代码

import multiprocessingdef worker(conn, a, b):"""子进程处理函数"""# 计算结果result = a * b# 向管道发送结果conn.send(result)if __name__ == '__main__':# 创建管道parent_conn, child_conn = multiprocessing.Pipe()# 创建进程池with multiprocessing.Pool() as pool:# 定义请求requests = [(1, 2), (3, 4), (5, 6)]# 提交任务到进程池results = [pool.apply_async(worker, args=(child_conn, a, b)) for a, b in requests]# 等待所有任务完成for _ in results:result = parent_conn.recv()print(f"Received result: {result}")# 打印所有结果print("All results:", [r.get() for r in results])

示例 2: 使用队列（Queue）进行进程池中的简单通信

在这个例子中，我们将使用队列来进行进程池中的简单通信。我们将创建一个主进程和一个进程池。主进程将发送乘法运算请求到队列中，进程池中的子进程将从队列中取出请求进行计算，并将结果发送回主进程。

示例代码

import multiprocessingdef worker(input_queue, output_queue):"""子进程处理函数"""while True:# 从队列接收消息data = input_queue.get()if data is None:breaka, b = data# 计算结果result = a * b# 向队列发送结果output_queue.put(result)if __name__ == '__main__':# 创建队列input_queue = multiprocessing.Queue()output_queue = multiprocessing.Queue()# 创建进程池with multiprocessing.Pool() as pool:# 提交任务到进程池workers = [pool.apply_async(worker, args=(input_queue, output_queue))]# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for request in requests:input_queue.put(request)# 接收结果results = []for _ in range(len(requests)):result = output_queue.get()results.append(result)print(f"Received result: {result}")# 发送结束信号for _ in range(len(workers)):input_queue.put(None)# 等待所有任务完成for w in workers:w.get()# 打印所有结果print("All results:", results)

解释

示例 1: 使用管道（Pipe）进行进程池中的简单通信

1. 我们创建了一个双向管道，它由 parent_conn 和 child_conn 组成。
2. 创建了一个进程池。
3. 主进程中，我们依次向进程池提交乘法请求，并定义了一个回调函数 worker，该函数将结果通过管道发给主进程。
4. 进程池内部调度执行任务，并通过管道将结果发送给主进程。
5. 主进程中，我们从管道接收结果，并打印出来。
6. 最后，我们通过 results 列表收集所有的结果。

示例 2: 使用队列（Queue）进行进程池中的简单通信

1. 我们创建了一个输入队列 input_queue 和一个输出队列 output_queue。
2. 创建了一个进程池。
3. 主进程中，我们依次向输入队列发送乘法请求。
4. 进程池中的子进程从输入队列接收请求，计算结果，并将结果通过输出队列发回给主进程。
5. 主进程中，我们从输出队列接收结果，并打印出来。
6. 最后，我们向输入队列发送 None 作为结束信号，并等待所有任务完成。

总结

这两种方法都可以有效地实现进程池中的简单通信。使用管道的方式更简单直接，适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信，特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。请注意，在使用进程池时，我们通常不需要直接管理进程间的通信，而是利用进程池提供的方法来间接实现。