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

Python多进程可以通过共享内存、使用Manager对象、使用Queue或Pipe进行进程间通信。共享内存最适合简单数据，Manager对象适合复杂数据结构，Queue和Pipe适合任务分配和结果收集。下面详细介绍这几种方法。

一、共享内存

共享内存是Python多进程中最直接的方式之一。通过multiprocessing.Value或multiprocessing.Array可以实现进程间共享简单数据类型，如整数、浮点数和数组。

1、使用 `multiprocessing.Value`

multiprocessing.Value 用于共享单一数据类型。它创建一个共享内存变量，允许多个进程读写。

from multiprocessing import Process, Value
import time
def increment_counter(counter):
    for _ in range(100):
        time.sleep(0.01)
        counter.value += 1
if __name__ == "__main__":
    counter = Value('i', 0)  # 'i' 表示整数类型
    process1 = Process(target=increment_counter, args=(counter,))
    process2 = Process(target=increment_counter, args=(counter,))
    process1.start()
    process2.start()
    process1.join()
    process2.join()
    print(f"Final counter value: {counter.value}")

在这个例子中，两个进程共同增量一个共享的整数变量counter。

2、使用 `multiprocessing.Array`

multiprocessing.Array 用于共享数组数据类型。

from multiprocessing import Process, Array
import time
def increment_array(shared_array):
    for i in range(len(shared_array)):
        time.sleep(0.01)
        shared_array[i] += 1
if __name__ == "__main__":
    shared_array = Array('i', [0, 1, 2, 3, 4])  # 'i' 表示整数类型
    process1 = Process(target=increment_array, args=(shared_array,))
    process2 = Process(target=increment_array, args=(shared_array,))
    process1.start()
    process2.start()
    process1.join()
    process2.join()
    print(f"Final shared array: {shared_array[:]}")

在这个例子中，两个进程共同增量一个共享的整数数组。

二、使用 Manager 对象

multiprocessing.Manager 提供了一个更高层次的接口，允许共享更复杂的数据结构，如列表和字典。

1、共享列表

from multiprocessing import Process, Manager
import time
def append_to_list(shared_list):
    for i in range(5):
        time.sleep(0.01)
        shared_list.append(i)
if __name__ == "__main__":
    with Manager() as manager:
        shared_list = manager.list()
        process1 = Process(target=append_to_list, args=(shared_list,))
        process2 = Process(target=append_to_list, args=(shared_list,))
        process1.start()
        process2.start()
        process1.join()
        process2.join()
        print(f"Final shared list: {shared_list}")

2、共享字典

from multiprocessing import Process, Manager
import time
def update_dict(shared_dict, key, value):
    time.sleep(0.01)
    shared_dict[key] = value
if __name__ == "__main__":
    with Manager() as manager:
        shared_dict = manager.dict()
        process1 = Process(target=update_dict, args=(shared_dict, 'a', 1))
        process2 = Process(target=update_dict, args=(shared_dict, 'b', 2))
        process1.start()
        process2.start()
        process1.join()
        process2.join()
        print(f"Final shared dict: {shared_dict}")

三、使用 Queue 或 Pipe

multiprocessing.Queue 和 multiprocessing.Pipe 提供了更灵活的进程间通信方式。它们常用于任务分配和结果收集。

1、使用 Queue

from multiprocessing import Process, Queue
def worker(queue):
    while not queue.empty():
        value = queue.get()
        print(f"Processed value: {value}")
if __name__ == "__main__":
    queue = Queue()
    for i in range(10):
        queue.put(i)
    process1 = Process(target=worker, args=(queue,))
    process2 = Process(target=worker, args=(queue,))
    process1.start()
    process2.start()
    process1.join()
    process2.join()

2、使用 Pipe

from multiprocessing import Process, Pipe
def worker(pipe):
    conn1, conn2 = pipe
    conn2.close()
    while True:
        msg = conn1.recv()
        if msg == "DONE":
            break
        print(f"Received message: {msg}")
if __name__ == "__main__":
    parent_conn, child_conn = Pipe()
    process = Process(target=worker, args=((parent_conn, child_conn),))
    process.start()
    child_conn.close()
    for i in range(10):
        parent_conn.send(f"Message {i}")
    parent_conn.send("DONE")
    process.join()

四、进程同步机制

在多进程编程中，确保进程间的同步是非常重要的。Python 提供了多种同步机制，如锁、事件、信号量和条件变量。

1、使用锁（Lock）

from multiprocessing import Process, Lock
import time
def increment_counter(counter, lock):
    for _ in range(100):
        time.sleep(0.01)
        with lock:
            counter.value += 1
if __name__ == "__main__":
    counter = Value('i', 0)
    lock = Lock()
    process1 = Process(target=increment_counter, args=(counter, lock))
    process2 = Process(target=increment_counter, args=(counter, lock))
    process1.start()
    process2.start()
    process1.join()
    process2.join()
    print(f"Final counter value: {counter.value}")

2、使用事件（Event）

from multiprocessing import Process, Event
import time
def worker(event):
    print("Worker waiting for event to be set")
    event.wait()
    print("Event has been set, worker proceeding")
if __name__ == "__main__":
    event = Event()
    process = Process(target=worker, args=(event,))
    process.start()
    time.sleep(2)
    event.set()
    process.join()

五、推荐项目管理系统

在多进程编程项目中，良好的项目管理系统是必不可少的。推荐使用以下两个系统：

研发项目管理系统PingCode：专为研发团队设计，提供强大的任务管理和进度跟踪功能。
通用项目管理软件Worktile：适用于各类团队，提供灵活的项目管理和协作工具。

这两个系统都能帮助团队更好地管理项目，提高工作效率。

总结来说，Python 提供了多种方法来实现多进程间的全局变量共享，包括共享内存、Manager对象、Queue和Pipe等方式。根据具体需求选择合适的方法，并结合进程同步机制，能够有效地实现多进程间的通信与协作。