python多进程运行如何返回值

在Python中，要在多进程运行中返回值，可以使用多种方法，例如使用 multiprocessing 模块中的 Queue、Pipe、Manager 等工具来实现。使用 Queue、Pipe、Manager 进行进程间通信、返回值、共享资源，是比较常见的方法。下面我们将详细介绍这些方法，并给出具体的代码示例。

一、使用 `Queue` 返回值

Queue 是 multiprocessing 模块中用于在进程之间传递数据的安全队列。使用 Queue，你可以将结果从子进程中传回到主进程中。

import multiprocessing
def worker(queue, x, y):
    result = x + y
    queue.put(result)
if __name__ == '__main__':
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(q, 3, 5))
    p.start()
    p.join()
    result = q.get()
    print(f'Result from child process: {result}')

在这个例子中，我们定义了一个 worker 函数，该函数接受一个队列和两个数，并将这两个数的和放入队列中。然后，我们在主进程中创建一个队列和一个子进程，并将结果从队列中取出。

二、使用 `Pipe` 返回值

Pipe 是另一种在进程之间传递数据的方法，它提供了一个双向通信的管道。

import multiprocessing
def worker(conn, x, y):
    result = x + y
    conn.send(result)
    conn.close()
if __name__ == '__main__':
    parent_conn, child_conn = multiprocessing.Pipe()
    p = multiprocessing.Process(target=worker, args=(child_conn, 3, 5))
    p.start()
    p.join()
    result = parent_conn.recv()
    print(f'Result from child process: {result}')

在这个例子中，我们使用 Pipe 创建了一个父连接和一个子连接，并在 worker 函数中通过子连接发送结果。在主进程中，我们通过父连接接收结果。

三、使用 `Manager` 返回值

Manager 提供了一个可以在多个进程之间共享的对象，如列表、字典等。

import multiprocessing
def worker(d, key, value):
    d[key] = value
if __name__ == '__main__':
    manager = multiprocessing.Manager()
    d = manager.dict()
    p = multiprocessing.Process(target=worker, args=(d, 'result', 8))
    p.start()
    p.join()
    result = d['result']
    print(f'Result from child process: {result}')

在这个例子中，我们使用 Manager 创建了一个共享字典，并在 worker 函数中将结果存储到字典中。在主进程中，我们从字典中获取结果。

四、使用 `Pool` 返回值

Pool 允许你管理进程池，并使用它们来执行并行计算。Pool 提供了多种方法，如 apply、apply_async、map、map_async 等来管理进程的返回值。

1、使用 `apply` 和 `apply_async`

apply 和 apply_async 用于在池中执行单个函数调用。

import multiprocessing
def worker(x, y):
    return x + y
if __name__ == '__main__':
    with multiprocessing.Pool(processes=2) as pool:
        result = pool.apply(worker, (3, 5))
        print(f'Result from pool.apply: {result}')
        async_result = pool.apply_async(worker, (3, 5))
        print(f'Result from pool.apply_async: {async_result.get()}')

2、使用 `map` 和 `map_async`

map 和 map_async 用于在池中并行执行多个函数调用。

import multiprocessing
def worker(x):
    return x * x
if __name__ == '__main__':
    with multiprocessing.Pool(processes=2) as pool:
        results = pool.map(worker, [1, 2, 3, 4, 5])
        print(f'Results from pool.map: {results}')
        async_results = pool.map_async(worker, [1, 2, 3, 4, 5])
        print(f'Results from pool.map_async: {async_results.get()}')

五、使用 `concurrent.futures` 模块

concurrent.futures 模块提供了一个高级接口来执行异步调用。你可以使用 ProcessPoolExecutor 来管理进程池。

import concurrent.futures
def worker(x, y):
    return x + y
if __name__ == '__main__':
    with concurrent.futures.ProcessPoolExecutor(max_workers=2) as executor:
        future = executor.submit(worker, 3, 5)
        result = future.result()
        print(f'Result from ProcessPoolExecutor: {result}')
        futures = [executor.submit(worker, i, i) for i in range(5)]
        results = [f.result() for f in futures]
        print(f'Results from ProcessPoolExecutor: {results}')

在这个例子中，我们使用 ProcessPoolExecutor 提交了一个任务，并通过 future.result() 方法获取了结果。我们还提交了多个任务，并通过列表推导式获取了所有结果。

六、进程同步与共享内存

有时候，除了返回值，我们还需要多个进程共享数据或同步工作。Python 的 multiprocessing 模块提供了锁（Lock）、信号量（Semaphore）、条件变量（Condition）等同步原语，以及共享内存（Value、Array）来实现这些功能。

1、使用锁同步进程

import multiprocessing
import time
def worker(lock, shared_resource):
    with lock:
        local_copy = shared_resource.value
        time.sleep(0.1)
        shared_resource.value = local_copy + 1
if __name__ == '__main__':
    lock = multiprocessing.Lock()
    shared_resource = multiprocessing.Value('i', 0)
    processes = [multiprocessing.Process(target=worker, args=(lock, shared_resource)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(f'Shared resource value: {shared_resource.value}')

在这个例子中，我们使用锁来同步对共享资源的访问，确保只有一个进程在任何时候修改共享资源。

2、使用条件变量协调进程

import multiprocessing
import time
def worker(condition, shared_resource):
    with condition:
        condition.wait()
        shared_resource.value += 1
if __name__ == '__main__':
    condition = multiprocessing.Condition()
    shared_resource = multiprocessing.Value('i', 0)
    processes = [multiprocessing.Process(target=worker, args=(condition, shared_resource)) for _ in range(10)]
    for p in processes:
        p.start()
    time.sleep(1)
    with condition:
        condition.notify_all()
    for p in processes:
        p.join()
    print(f'Shared resource value: {shared_resource.value}')