进程间通信

合集 - python高级(31)

1.创建进程2023-07-232.Process类语法详解2023-07-23

3.进程间通信2023-07-23

4.进程池2023-07-235.进程间的锁和信号量2023-07-236.根据进程编号杀死指定进程os.kill2023-07-237.守护进程2023-07-238.线程2023-07-289.实现多线程多任务的步骤2023-07-2810.threading.Thread类详解2023-07-2811.守护线程&&threading.enumerate()2023-07-2812.python线程并行执行与java的线程并行执行的对比2023-07-2913.IO密集型任务与CPU密集型任务2023-07-2914.多线程共享全局变量的问题2023-07-2915.多线程共享资源之竞态条件2023-07-2916.互斥锁2023-07-2917.死锁2023-07-2918.线程池2023-07-2919.进程与线程的对比2023-07-2920.闭包2023-08-2621.闭包之nonlocal关键字的作用2023-08-2622.闭包之作用2023-08-2623.闭包之可能引起的问题2023-08-2624.弱引用2023-08-2625.装饰器2023-08-2726.装饰器示例2023-08-2727.property 属性2023-08-2728.with语句和上下文管理器详解、最佳实践、示例2023-08-2929.生成器2023-08-2930.深浅拷贝2023-08-3031.正则表达式2023-08-30

收起

说明

进程间除了主子进程共享数据，也可以通过进程间通信实现交互、数据共享

multiprocessing 提供了多种方式来实现进程间通信，如管道（Pipe）、队列（Queue）和共享内存（Value 和 Array）等。

通过这些机制，不同进程之间可以安全地共享数据或进行通信

 

进程间是不共享全局变量的.
实际上创建一个子进程就是把主进程的资源进行拷贝产生了一个新的进程,这里主进程和子进程是相互独立的.

 

 

 

创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

队列（Queue）

from multiprocessing import Process, Queue


def worker(q):
    data = q.get()
    # 子进程处理/消费，主进程的生产的数据
    print("Received data:", data)  # ['data from main process', 'data from child process']


if __name__ == '__main__':
    q = Queue()
    p = Process(target=worker, args=(q,))
    p.start()
    #  主进程塞进去/生产一个数据
    q.put("Hello from main process")

管道（Pipe）

'''
1. 创建管道对象
使用 Pipe() 函数创建了一个管道对象，返回两个连接对象 parent_conn 和 child_conn。parent_conn 用于从父进程向子进程发送消息，child_conn 用于从子进程接收消息。

2. 创建发送和接收进程，并传递管道连接对象
    分别创建了发送进程 sender_process 和接收进程 receiver_process，并通过参数传递了相应的管道连接对象。这样，这两个进程就可以使用各自的连接对象进行通信。

3. 启动进程
    使用 start() 方法启动发送和接收进程，它们会并行地执行任务。

4. 等待进程结束
    使用 join() 方法阻塞等待发送和接收进程结束。这样，主进程会等待子进程完成任务后再继续执行。

在具体的任务函数中，sender() 函数使用 conn.send() 方法向管道发送一条消息 "Hello from sender"，然后关闭连接。receiver() 函数使用 conn.recv() 方法接收来自管道的消息，并打印出来，然后关闭连接。
'''
from multiprocessing import Process, Pipe


def sender(conn):
    message = "Hello from sender"
    conn.send(message)
    conn.close()


def receiver(conn):
    message = conn.recv()
    print("Received message:", message) # Received message: Hello from sender

 conn.close() 29 30 31 if __name__ == '__main__': 32 # 1. 创建管道对象 33 parent_conn, child_conn = Pipe() 34 35 # 2. 创建发送和接收进程，并传递管道连接对象 36 sender_process = Process(target=sender, args=(parent_conn,)) 37 receiver_process = Process(target=receiver, args=(child_conn,)) 38 39 # 3. 启动进程 40  sender_process.start() 41  receiver_process.start() 42 43 # 4. 等待进程结束 44  sender_process.join() 45 receiver_process.join()

 

进程间通信共享内存（Value 和 Array）

Value

'''
在多进程编程中，可以使用 Value 和 Array 来实现进程间共享内存的通信
Value 类用于在进程间共享单个值，它是基于 ctypes 模块实现的。Value 可以通过指定的数据类型来创建共享变量，支持整型、浮点型和自定义的 ctypes 数据类型。
'''
from multiprocessing import Process, Value


def worker(shared_value):
    shared_value.value = 100


if __name__ == '__main__':
    # 创建共享值对象，初始值为0
    shared_value = Value('i', 0)

    # 创建子进程，并传递共享值对象
    p = Process(target=worker, args=(shared_value,))
    p.start()
    p.join()

    # 打印共享值对象的值
    print(shared_value.value)  # 100

使用 Value('i', 0) 创建了一个共享的整型值对象 shared_value，初始值为0。然后，我们创建了一个子进程 p，并将 shared_value 作为参数传递给子进程的任务函数 worker。在子进程中，我们将 shared_value.value 设置为100。

最后，在主进程中，我们打印了 shared_value.value 的值，可以看到它已经被子进程修改为100。

Array

'''
Array 类用于在进程间共享可变数组，它也是基于 ctypes 模块实现的。Array 可以通过指定的数据类型和大小来创建共享数组，支持整型、浮点型和自定义的 ctypes 数据类型。
'''

from multiprocessing import Process, Array


def worker(shared_array):
    for i in range(len(shared_array)):
        shared_array[i] = i * 2  # 给array添加元素


if __name__ == '__main__':
    # 创建共享数组对象，大小为5
    shared_array = Array('i', 5)

    # 创建子进程，并传递共享数组对象
    p = Process(target=worker, args=(shared_array,))
    p.start()
    p.join()

    # 打印共享数组对象的值
    print(list(shared_array))  # [0, 2, 4, 6, 8]，需要转换为list
    print(shared_array)  # <SynchronizedArray wrapper for <multiprocessing.sharedctypes.c_long_Array_5 object at 0x000001E86912FB50>>

 使用 Array('i', 5) 创建了一个包含5个整型元素的共享数组对象 shared_array。然后，我们创建了一个子进程 p，并将 shared_array 作为参数传递给子进程的任务函数 worker。在子进程中，我们将 shared_array 的每个元素设置为索引乘以2的值。