Python实现Windows环境下跨进程内存共享技术详解

在 Windows 系统中，实现不同进程间内存共享的一种常见方法是使用 **共享内存（Shared Memory）**。Python 提供了多种方式来实现这一功能，其中 `multiprocessing` 模块中的 `shared_memory` 子模块（自 Python 3.8 起引入）是一个简便且高效的解决方案。

以下是使用 `multiprocessing.shared_memory` 实现不同进程间内存共享的示例：

示例场景

假设我们有两个进程，一个进程写入数据到共享内存，另一个进程从共享内存读取数据。

步骤概述

1. **创建共享内存**：写入进程创建一块共享内存，并写入数据。
2. **访问共享内存**：读取进程打开同一块共享内存，并读取数据。

示例代码

import multiprocessing from multiprocessing

import shared_memory
import time

def writer(shared_mem_name, data):
    # 创建共享内存
    shm = shared_memory.SharedMemory(name=shared_mem_name, create=True, size=len(data))
    print(f"Writer: Shared memory '{shm.name}' created.")
    
    # 将数据写入共享内存
    shm.buf[:len(data)] = data.encode('utf-8')
    print(f"Writer: Data written to shared memory.")
    
    # 保持共享内存存在一段时间，以便读取进程访问
    time.sleep(5)
    
    # 关闭并释放共享内存
    shm.close()
    shm.unlink()
    print(f"Writer: Shared memory '{shm.name}' closed and unlinked.")

def reader(shared_mem_name):
    # 等待共享内存创建
    time.sleep(1)
    
    # 打开已存在的共享内存
    shm = shared_memory.SharedMemory(name=shared_mem_name)
    print(f"Reader: Shared memory '{shm.name}' opened.")
    
    # 读取共享内存中的数据
    data = shm.buf[:].decode('utf-8')
    print(f"Reader: Data read from shared memory: {data}")
    
    # 关闭共享内存
    shm.close()
    print(f"Reader: Shared memory '{shm.name}' closed.")

if __name__ == "__main__":
    shared_mem_name = "MySharedMemory"
    data_to_share = "Hello from shared memory!"

    # 创建写入和读取进程
    writer_process = multiprocessing.Process(target=writer, args=(shared_mem_name, data_to_share))
    reader_process = multiprocessing.Process(target=reader, args=(shared_mem_name,))

    # 启动进程
    writer_process.start()
    reader_process.start()

    # 等待进程结束
    writer_process.join()
    reader_process.join()

    print("Main process: Completed.")

代码说明

1. **共享内存创建与写入（writer 函数）**：
– 使用 `SharedMemory` 创建一块命名共享内存，名称为 `"MySharedMemory"`。
– 将要共享的字符串数据编码为字节并写入共享内存。
– 保持进程运行一段时间（通过 `time.sleep(5)`），以确保读取进程有足够时间访问共享内存。
– 关闭并释放共享内存。

2. **共享内存读取（reader 函数）**：
– 等待一段时间后，打开已存在的共享内存。
– 从共享内存中读取数据并解码为字符串。
– 关闭共享内存。

3. **主进程**：
– 定义共享内存的名称和要共享的数据。
– 创建并启动写入和读取进程。
– 等待两个进程完成后结束主进程。

运行结果

运行上述代码后，你应该会看到类似以下的输出：

Writer: Shared memory 'MySharedMemory' created.
Writer: Data written to shared memory.
Reader: Shared memory 'MySharedMemory' opened.
Reader: Data read from shared memory: Hello from shared memory!
Writer: Shared memory 'MySharedMemory' closed and unlinked.
Reader: Shared memory 'MySharedMemory' closed.
Main process: Completed.

注意事项

1. **同步问题**：上述示例中为了简化，使用了 `time.sleep` 来同步进程。在实际应用中，建议使用锁（`multiprocessing.Lock`）或其他同步机制来确保数据的一致性和完整性。

2. **数据类型限制**：`SharedMemory` 主要用于共享字节数据。如果需要共享复杂的数据结构，可以使用 `multiprocessing.Array` 或 `multiprocessing.Value`，或者考虑使用第三方库如 `pywin32` 来调用 Windows API 实现更高级的共享内存功能。

3. **资源管理**：确保所有使用共享内存的进程在不需要时正确关闭和释放共享内存，以避免资源泄漏。

进阶

使用 `multiprocessing.Array` 和 `Value`，除了 `SharedMemory`，`multiprocessing` 模块还提供了 `Array` 和 `Value` 来共享简单的数据类型和数组：

from multiprocessing import Process, Array

def writer(shared_array):
    shared_array[:] = [i for i in range(10)]
    print("Writer: Data written to array.")

def reader(shared_array):
    print("Reader: Data read from array:", shared_array[:])

if __name__ == "__main__":
    shared_array = Array('i', 10)  # 'i'表示整数类型，10是数组长度

    writer_process = Process(target=writer, args=(shared_array,))
    reader_process = Process(target=reader, args=(shared_array,))

    writer_process.start()
    writer_process.join()  # 确保写入完成

    reader_process.start()
    reader_process.join()

    print("Main process: Completed.")

这个示例展示了如何共享一个整数数组。`Array` 和 `Value` 提供了更高层次的接口，适用于共享简单的数据结构。