python进程间如何共享

Python进程间共享数据的方式主要包括：使用共享内存、消息队列、管道和套接字、以及多处理模块中的Manager对象。 其中，使用共享内存和消息队列是较为常用的方法。共享内存可以通过multiprocessing模块中的Value和Array类实现，这种方法适用于简单的数据类型。而对于复杂数据结构，使用Manager对象来创建共享的列表、字典等更为合适。接下来，将详细介绍其中一种方法——使用Manager对象。

使用Manager对象来共享复杂数据结构：

在多进程编程中，通常需要共享一些复杂的数据结构，如列表、字典等。Python中的multiprocessing.Manager提供了一个简单易用的接口，可以创建受管理的共享数据结构，这些结构可以被多个进程安全地访问和修改。

Manager对象可以创建共享的列表、字典、Namespace等数据结构。创建一个Manager对象后，可以通过它的list()、dict()方法创建一个共享的列表或字典。例如：

from multiprocessing import Process, Manager
def worker(shared_list):
    shared_list.append("data from worker")
if __name__ == "__main__":
    with Manager() as manager:
        shared_list = manager.list()  # 创建一个共享列表
        p = Process(target=worker, args=(shared_list,))
        p.start()
        p.join()
        print(shared_list)

在上面的代码中，manager.list()创建了一个共享列表shared_list，并在子进程中通过append方法向列表中添加数据。这些修改在主进程中是可见的。

一、使用共享内存

共享内存是一种常见的进程间通信方式，适用于存储简单的数值类型数据。在Python中，通过multiprocessing模块提供的Value和Array可以实现共享内存。

Value：用于存储单个数据的共享内存。

Value创建的是一个存储单一数据类型的共享变量，它支持多种数据类型，如int、float等。

from multiprocessing import Process, Value
def add_one(shared_value):
    with shared_value.get_lock():  # 获取锁
        shared_value.value += 1
if __name__ == "__main__":
    shared_value = Value('i', 0)  # 创建一个整型共享变量
    processes = [Process(target=add_one, args=(shared_value,)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(shared_value.value)

在上面的代码中，Value('i', 0)创建了一个共享整型变量，初始值为0。每个子进程都对共享变量加1，最后输出结果为10。

Array：用于存储数组的共享内存。

Array创建的是一个共享数组，支持各种基础数据类型。

from multiprocessing import Process, Array
def increment_array(shared_array):
    for i in range(len(shared_array)):
        with shared_array.get_lock():  # 获取锁
            shared_array[i] += 1
if __name__ == "__main__":
    shared_array = Array('i', [0, 0, 0])  # 创建一个整型数组
    processes = [Process(target=increment_array, args=(shared_array,)) for _ in range(3)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(list(shared_array))

在上面的代码中，Array('i', [0, 0, 0])创建了一个共享整型数组，初始值为[0, 0, 0]。每个子进程都对数组中的每个元素加1，最终输出结果为[3, 3, 3]。

二、使用消息队列

消息队列是一种常用的进程间通信机制，适用于需要传递复杂数据结构的场景。Python中的multiprocessing.Queue可以实现进程间的消息队列。

Queue：多进程安全的队列。

Queue提供了先进先出的队列结构，支持多进程安全的put和get操作。

from multiprocessing import Process, Queue
def producer(queue):
    for item in range(5):
        queue.put(item)
def consumer(queue):
    while not queue.empty():
        item = queue.get()
        print(f"Consumed: {item}")
if __name__ == "__main__":
    queue = Queue()  # 创建队列
    producer_process = Process(target=producer, args=(queue,))
    consumer_process = Process(target=consumer, args=(queue,))
    producer_process.start()
    consumer_process.start()
    producer_process.join()
    consumer_process.join()

在上面的代码中，Queue()创建了一个消息队列。生产者进程通过put方法将数据放入队列，消费者进程通过get方法从队列中获取数据并处理。

三、使用管道和套接字

管道和套接字是进程间通信的低级实现，适用于需要在进程之间传递数据流的场景。

Pipe：双向通信的管道。

Pipe可以创建一个双向通信的管道，返回两个连接对象，分别用于发送和接收数据。

from multiprocessing import Process, Pipe
def sender(conn):
    conn.send("Hello from sender")
    conn.close()
def receiver(conn):
    message = conn.recv()
    print(f"Received: {message}")
if __name__ == "__main__":
    parent_conn, child_conn = Pipe()  # 创建管道
    sender_process = Process(target=sender, args=(child_conn,))
    receiver_process = Process(target=receiver, args=(parent_conn,))
    sender_process.start()
    receiver_process.start()
    sender_process.join()
    receiver_process.join()

在上面的代码中，Pipe()创建了一个管道，返回的parent_conn和child_conn分别用于发送和接收数据。

Socket：基于TCP/IP的通信。

套接字是更底层的通信方式，通常用于网络通信，也可以用于进程间通信。

import socket
from multiprocessing import Process
def server():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('localhost', 6000))
    server_socket.listen(1)
    conn, addr = server_socket.accept()
    print(f"Connected by {addr}")
    data = conn.recv(1024)
    print(f"Received: {data.decode()}")
    conn.close()
def client():
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(('localhost', 6000))
    client_socket.sendall(b"Hello from client")
    client_socket.close()
if __name__ == "__main__":
    server_process = Process(target=server)
    client_process = Process(target=client)
    server_process.start()
    client_process.start()
    server_process.join()
    client_process.join()

在上面的代码中，通过套接字在本地创建了一个简单的客户端和服务器，服务器接收来自客户端的数据。

四、使用多处理模块中的Manager对象

Manager对象不仅可以创建共享的列表和字典，还可以创建其他类型的共享对象，如Namespace、Lock、RLock、Semaphore、BoundedSemaphore、Condition、Event、Barrier等。

共享字典

from multiprocessing import Process, Manager
def worker(shared_dict):
    shared_dict["key"] = "value from worker"
if __name__ == "__main__":
    with Manager() as manager:
        shared_dict = manager.dict()  # 创建一个共享字典
        p = Process(target=worker, args=(shared_dict,))
        p.start()
        p.join()
        print(shared_dict)

在上面的代码中，manager.dict()创建了一个共享字典shared_dict，并在子进程中对字典进行修改。这些修改在主进程中是可见的。

共享Namespace

Namespace对象可以用于存储多个属性，是一种简单的共享对象。

from multiprocessing import Process, Manager
def worker(shared_namespace):
    shared_namespace.value = "value from worker"
if __name__ == "__main__":
    with Manager() as manager:
        shared_namespace = manager.Namespace()  # 创建一个共享Namespace对象
        p = Process(target=worker, args=(shared_namespace,))
        p.start()
        p.join()
        print(shared_namespace.value)