python使用multiprocessing多进程通讯

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）进行多个进程间的简单通信

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 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）进行进程池中的简单通信

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 作为结束信号，并等待所有任务完成。

总结

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