python如何做到進程共享內存

Python中可以通过多种方式实现进程间的内存共享，包括使用 multiprocessing 模块、共享内存对象、以及 mmap 模块。最常用的方法是使用 multiprocessing 模块中的 Value 和 Array 类。

multiprocessing.Value 和 multiprocessing.Array 提供了支持进程间共享数据的简单方法。其中，Value 用于共享单个数据，而 Array 用于共享数组。下面我们将详细介绍如何使用这些方法实现进程间的内存共享，并讨论它们的优点和局限性。

一、multiprocessing 模块

multiprocessing 模块是 Python 提供的多进程处理模块，它允许你创建多个进程，并提供了多个工具来实现进程间通信和同步。

1、Value 类

Value 类可以创建一个共享的变量，这个变量可以在多个进程间共享。你需要指定变量的类型和初始值。以下是一个示例：

from multiprocessing import Process, Value
import time
def increment_value(shared_value):
    for _ in range(100):
        with shared_value.get_lock():  # 获取锁，以确保原子操作
            shared_value.value += 1
        time.sleep(0.01)
if __name__ == '__main__':
    shared_value = Value('i', 0)  # 创建一个共享整型变量，初始值为0
    processes = [Process(target=increment_value, args=(shared_value,)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(shared_value.value)  # 输出结果应为1000（100次增加*10个进程）

在这个示例中，我们创建了一个共享的整型变量 shared_value，并创建了10个进程，每个进程都会增加该变量的值。通过使用 shared_value.get_lock()，我们确保每次增操作都是原子的。

2、Array 类

Array 类则用于创建共享的数组。你需要指定数组的类型码和长度。以下是一个示例：

from multiprocessing import Process, Array
import time
def increment_array(shared_array):
    for _ in range(100):
        with shared_array.get_lock():  # 获取锁，以确保原子操作
            for i in range(len(shared_array)):
                shared_array[i] += 1
        time.sleep(0.01)
if __name__ == '__main__':
    shared_array = Array('i', 10)  # 创建一个包含10个整型元素的共享数组
    processes = [Process(target=increment_array, args=(shared_array,)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(list(shared_array))  # 输出结果应为[1000, 1000, ..., 1000]

在这个示例中，我们创建了一个包含10个整型元素的共享数组 shared_array，并创建了10个进程，每个进程都会增加数组中每个元素的值。通过使用 shared_array.get_lock()，我们确保每次增操作都是原子的。

二、共享内存对象（SharedMemory）

Python 3.8 引入了共享内存（SharedMemory）对象，使得进程间共享内存更加方便和高效。

1、SharedMemory 类

SharedMemory 类允许你创建和管理共享内存块。以下是一个示例：

from multiprocessing import Process
from multiprocessing.shared_memory import SharedMemory
import numpy as np
def modify_shared_memory(shared_mem_name, shape, dtype):
    existing_shm = SharedMemory(name=shared_mem_name)
    array = np.ndarray(shape, dtype=dtype, buffer=existing_shm.buf)
    array += 1  # 增加数组的每个元素
    existing_shm.close()
if __name__ == '__main__':
    shape = (10,)
    dtype = np.int32
    shm = SharedMemory(create=True, size=np.prod(shape) * np.dtype(dtype).itemsize)
    array = np.ndarray(shape, dtype=dtype, buffer=shm.buf)
    array[:] = 0  # 初始化数组
    processes = [Process(target=modify_shared_memory, args=(shm.name, shape, dtype)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(array)  # 输出结果应为[10, 10, ..., 10]
    shm.close()
    shm.unlink()

在这个示例中，我们创建了一个共享内存块 shm，并使用 NumPy 数组进行管理。我们创建了10个进程，每个进程都会增加数组中每个元素的值。

三、mmap 模块

mmap 模块允许你将文件映射到内存中，从而实现进程间共享内存。以下是一个示例：

import mmap
import os
import time
from multiprocessing import Process
def modify_mmap(filename, size):
    with open(filename, "r+b") as f:
        mm = mmap.mmap(f.fileno(), size)
        for i in range(size):
            mm[i] = (mm[i] + 1) % 256  # 增加每个字节的值
        mm.close()
if __name__ == '__main__':
    filename = "shared_memory.bin"
    size = 10
    # 创建一个文件并初始化内容
    with open(filename, "wb") as f:
        f.write(bytearray(size))
    processes = [Process(target=modify_mmap, args=(filename, size)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    with open(filename, "rb") as f:
        data = f.read()
        print(list(data))  # 输出结果应为[10, 10, ..., 10]
    os.remove(filename)