python多进程如何共享全局变量

使用多进程共享全局变量的几种方法：使用 multiprocessing.Manager、使用 multiprocessing.Array 和 multiprocessing.Value、使用 multiprocessing.Queue、使用 multiprocessing.Pipe。在这几种方法中，multiprocessing.Manager 是最通用和灵活的方式，它允许多个进程共享复杂的 Python 对象（如列表和字典）。下面将详细介绍如何使用 multiprocessing.Manager 来共享全局变量。

一、使用 `multiprocessing.Manager`

multiprocessing.Manager 提供了一个管理器对象，可以用于在多个进程之间共享数据。管理器支持多种数据类型，如列表、字典、命名空间等。

1. 创建并共享全局变量

在使用 multiprocessing.Manager 之前，首先需要导入相关模块并创建一个管理器对象：

import multiprocessing
def worker(shared_dict, key, value):
    shared_dict[key] = value
if __name__ == '__main__':
    manager = multiprocessing.Manager()
    shared_dict = manager.dict()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_dict, i, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    print(shared_dict)

在上述示例中，我们创建了一个共享字典 shared_dict，并通过多个进程向其中添加键值对。每个进程都将自己的计算结果存储在共享字典中，最终在主进程中打印出共享字典的内容。

2. 使用共享列表

除了共享字典外，还可以使用共享列表：

import multiprocessing
def worker(shared_list, index, value):
    shared_list[index] = value
if __name__ == '__main__':
    manager = multiprocessing.Manager()
    shared_list = manager.list([0] * 5)
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_list, i, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    print(shared_list)

在这个示例中，我们创建了一个共享列表 shared_list，并通过多个进程向其中添加计算结果。每个进程都将自己的计算结果存储在共享列表的相应位置，最终在主进程中打印出共享列表的内容。

二、使用 `multiprocessing.Array` 和 `multiprocessing.Value`

multiprocessing.Array 和 multiprocessing.Value 提供了一种简单的方式来共享数据，但是它们仅支持共享基本的数据类型（如整数和浮点数）。

1. 使用 `multiprocessing.Array`

可以使用 multiprocessing.Array 来创建一个共享数组：

import multiprocessing
def worker(shared_array, index, value):
    shared_array[index] = value
if __name__ == '__main__':
    shared_array = multiprocessing.Array('i', [0] * 5)
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_array, i, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    print(shared_array[:])

在这个示例中，我们创建了一个共享数组 shared_array，并通过多个进程向其中添加计算结果。每个进程都将自己的计算结果存储在共享数组的相应位置，最终在主进程中打印出共享数组的内容。

2. 使用 `multiprocessing.Value`

可以使用 multiprocessing.Value 来创建一个共享变量：

import multiprocessing
def worker(shared_value, value):
    shared_value.value = value
if __name__ == '__main__':
    shared_value = multiprocessing.Value('i', 0)
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_value, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    print(shared_value.value)

在这个示例中，我们创建了一个共享变量 shared_value，并通过多个进程修改其值。最终在主进程中打印出共享变量的值。

三、使用 `multiprocessing.Queue`

multiprocessing.Queue 提供了一种线程安全的队列，可以用于在多个进程之间传递数据。

1. 创建并共享队列

可以使用 multiprocessing.Queue 来创建一个共享队列：

import multiprocessing
def worker(queue, value):
    queue.put(value)
if __name__ == '__main__':
    queue = multiprocessing.Queue()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(queue, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    while not queue.empty():
        print(queue.get())

在这个示例中，我们创建了一个共享队列 queue，并通过多个进程向其中添加计算结果。每个进程都将自己的计算结果存储在共享队列中，最终在主进程中打印出共享队列的内容。

四、使用 `multiprocessing.Pipe`

multiprocessing.Pipe 提供了一种双向通信的管道，可以用于在两个进程之间传递数据。

1. 创建并共享管道

可以使用 multiprocessing.Pipe 来创建一个共享管道：

import multiprocessing
def worker(pipe, value):
    pipe.send(value)
    pipe.close()
if __name__ == '__main__':
    parent_conn, child_conn = multiprocessing.Pipe()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(child_conn, i * 2))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    while parent_conn.poll():
        print(parent_conn.recv())

在这个示例中，我们创建了一个共享管道 parent_conn 和 child_conn，并通过多个进程向其中添加计算结果。每个进程都将自己的计算结果存储在共享管道中，最终在主进程中打印出共享管道的内容。

总结

在 Python 中，通过 multiprocessing.Manager、multiprocessing.Array 和 multiprocessing.Value、multiprocessing.Queue、multiprocessing.Pipe 等多种方式，可以实现多进程共享全局变量的需求。根据具体的应用场景和需求选择合适的方法，可以有效地提高程序的并行处理能力和执行效率。