python使用multiprocessing多进程通讯
python使用multiprocessing，多进程通讯
-
- 1 使用管道（Pipe）和使用队列（Queue）
- 2 进行父进程和子进程间的简单通信
-
- 1. 使用管道（Pipe）
-
- 示例代码
- 2. 使用队列（Queue）
-
- 示例代码
- 总结
- 3 进行多个进程间的简单通信
-
- 示例 1: 使用管道（Pipe）进行多个进程间的简单通信
-
- 示例代码
- 示例 2: 使用队列（Queue）进行多个进程间的简单通信
-
- 示例代码
- 解释
-
- 示例 1: 使用管道（Pipe）进行多个进程间的简单通信
- 示例 2: 使用队列（Queue）进行多个进程间的简单通信
- 总结
- 4 进程池中的简单通信
-
- 示例 1: 使用管道（Pipe）进行进程池中的简单通信
-
- 示例代码
- 示例 2: 使用队列（Queue）进行进程池中的简单通信
-
- 示例代码
- 解释
-
- 示例 1: 使用管道（Pipe）进行进程池中的简单通信
- 示例 2: 使用队列（Queue）进行进程池中的简单通信
- 总结
1 使用管道（Pipe）和使用队列（Queue）
在Python中，multiprocessing模块提供了一种简单的方式来利用多核处理器进行并行处理。对于进程间的通信，multiprocessing模块提供了几种机制，其中最常用的是管道（Pipe）和队列（Queue）。下面我将详细介绍这两种方法，并给出相应的示例代码。
2 进行父进程和子进程间的简单通信
1. 使用管道（Pipe）
管道是进程间通信的一种非常直接的方式。它可以实现两个进程之间的双向通信。multiprocessing.Pipe() 函数创建一对连接两端的管道对象。
示例代码
这里有一个使用管道进行进程间通信的例子：
import multiprocessing
def 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 multiprocessing
def 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 multiprocessing
def worker(conn):
"""子进程处理函数"""
while True:
# 从管道接收消息
data = conn.recv()
if data is None:
break
a, 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 multiprocessing
def worker(input_queue, output_queue):
"""子进程处理函数"""
while True:
# 从队列接收消息
data = input_queue.get()
if data is None:
break
a, 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）进行多个进程间的简单通信
- 我们创建了两个双向管道，它们由
parent_conn和child_conn组成。 - 创建了两个子进程
processes，它们调用worker函数，并传入child_conn作为参数。 - 主进程中，我们依次向管道发送乘法请求。
- 子进程中，我们从管道接收请求，计算结果，并将结果通过管道发回给主进程。
- 主进程中，我们从管道接收结果，并打印出来。
- 最后，我们向管道发送
None作为结束信号，并等待子进程结束。
示例 2: 使用队列（Queue）进行多个进程间的简单通信
- 我们创建了一个输入队列
input_queue和一个输出队列output_queue。 - 创建了两个子进程
processes，它们调用worker函数，并传入两个队列作为参数。 - 主进程中，我们依次向输入队列发送乘法请求。
- 子进程中，我们从输入队列接收请求，计算结果，并将结果通过输出队列发回给主进程。
- 主进程中，我们从输出队列接收结果，并打印出来。
- 最后，我们向输入队列发送
None作为结束信号，并等待子进程结束。
总结
这两种方法都可以有效地实现多个进程间的简单通信。使用管道的方式更简单直接，适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信，特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。
4 进程池中的简单通信
当然可以！下面我将提供两个简单的例子来展示如何使用 Python 的 multiprocessing 模块中的 Pool 类进行多个并行进程间的通信。我们将分别使用管道（Pipe）和队列（Queue）来实现这一目标。
示例 1: 使用管道（Pipe）进行进程池中的简单通信
在这个例子中，我们将创建一个主进程和一个进程池。主进程将发送乘法运算请求给进程池中的子进程，子进程将计算结果并将其返回给主进程。
示例代码
import multiprocessing
def 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 multiprocessing
def worker(input_queue, output_queue):
"""子进程处理函数"""
while True:
# 从队列接收消息
data = input_queue.get()
if data is None:
break
a, 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）进行进程池中的简单通信
- 我们创建了一个双向管道，它由
parent_conn和child_conn组成。 - 创建了一个进程池。
- 主进程中，我们依次向进程池提交乘法请求，并定义了一个回调函数
worker，该函数将结果通过管道发给主进程。 - 进程池内部调度执行任务，并通过管道将结果发送给主进程。
- 主进程中，我们从管道接收结果，并打印出来。
- 最后，我们通过
results列表收集所有的结果。
示例 2: 使用队列（Queue）进行进程池中的简单通信
- 我们创建了一个输入队列
input_queue和一个输出队列output_queue。 - 创建了一个进程池。
- 主进程中，我们依次向输入队列发送乘法请求。
- 进程池中的子进程从输入队列接收请求，计算结果，并将结果通过输出队列发回给主进程。
- 主进程中，我们从输出队列接收结果，并打印出来。
- 最后，我们向输入队列发送
None作为结束信号，并等待所有任务完成。
总结
这两种方法都可以有效地实现进程池中的简单通信。使用管道的方式更简单直接，适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信，特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。请注意，在使用进程池时，我们通常不需要直接管理进程间的通信，而是利用进程池提供的方法来间接实现。