python中多进程之间如何通信

Python中多进程之间可以通过队列（Queue）、管道（Pipe）、共享内存（Value和Array）、Manager对象进行通信。其中，队列是最常用的方式之一，因为它简单且线程安全。

通过队列进行多进程通信是一种高效且常用的方法。在多进程编程中，我们需要在进程之间传递数据，而队列提供了一种FIFO（先进先出）数据结构，使得数据的传递变得更加有序和简单。队列可以让一个进程将数据放入队列中，另一个进程从队列中读取数据，从而实现进程间的通信。

一、队列（Queue）

队列是多进程通信中最常用的一种方式。Python的multiprocessing模块提供了Queue类，支持跨进程通信。队列是线程安全的，可以在多个进程之间共享。

1. 使用队列进行通信

队列的使用非常简单，可以通过put方法将数据放入队列，通过get方法从队列中读取数据。

from multiprocessing import Process, Queue
def producer(q):
    for i in range(5):
        q.put(i)
        print(f"Produced {i}")
def consumer(q):
    while not q.empty():
        item = q.get()
        print(f"Consumed {item}")
if __name__ == "__main__":
    q = Queue()
    p1 = Process(target=producer, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()

在上面的例子中，producer函数将数据放入队列，而consumer函数从队列中读取数据。主进程创建了两个子进程，一个用于生产数据，一个用于消费数据。

2. 队列的常用方法

put(item): 将item放入队列。
get(): 从队列中获取一个项目。
empty(): 如果队列为空，返回True。
full(): 如果队列已满，返回True。

二、管道（Pipe）

管道是一种更底层的通信机制，适用于两个进程之间的通信。multiprocessing模块提供了Pipe函数来创建一个管道，该函数返回两个连接对象，分别代表管道的两端。

1. 使用管道进行通信

from multiprocessing import Process, Pipe
def producer(conn):
    for i in range(5):
        conn.send(i)
        print(f"Produced {i}")
    conn.close()
def consumer(conn):
    while True:
        try:
            item = conn.recv()
            print(f"Consumed {item}")
        except EOFError:
            break
if __name__ == "__main__":
    parent_conn, child_conn = Pipe()
    p1 = Process(target=producer, args=(parent_conn,))
    p2 = Process(target=consumer, args=(child_conn,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

在上面的例子中，producer函数通过send方法将数据发送到管道，而consumer函数通过recv方法从管道中接收数据。

三、共享内存（Value和Array）

共享内存允许多个进程共享数据。multiprocessing模块提供了Value和Array类来创建共享内存。

1. 使用Value进行通信

Value类用于存储单个数据。

from multiprocessing import Process, Value
def producer(val):
    val.value = 100
    print("Produced 100")
def consumer(val):
    print(f"Consumed {val.value}")
if __name__ == "__main__":
    val = Value('i', 0)
    p1 = Process(target=producer, args=(val,))
    p2 = Process(target=consumer, args=(val,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()

2. 使用Array进行通信

Array类用于存储数组数据。

from multiprocessing import Process, Array
def producer(arr):
    for i in range(len(arr)):
        arr[i] = i
    print("Produced array")
def consumer(arr):
    print(f"Consumed {list(arr)}")
if __name__ == "__main__":
    arr = Array('i', 5)
    p1 = Process(target=producer, args=(arr,))
    p2 = Process(target=consumer, args=(arr,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()

四、Manager对象

Manager对象提供了更高级的共享数据结构，如列表、字典等。multiprocessing.Manager返回的Manager对象可以创建这些共享数据结构，并在多个进程之间共享。

1. 使用Manager进行通信

from multiprocessing import Process, Manager
def producer(d):
    d[1] = 'a'
    d[2] = 'b'
    print("Produced dictionary")
def consumer(d):
    print(f"Consumed {d}")
if __name__ == "__main__":
    with Manager() as manager:
        d = manager.dict()
        p1 = Process(target=producer, args=(d,))
        p2 = Process(target=consumer, args=(d,))
        p1.start()
        p1.join()
        p2.start()
        p2.join()