Python单例多进程测试：pytest与手动调用行为差异解析

1. 进程内单例的本质局限 #

你实现的SingletonMeta是进程私有单例：它依赖类内部的_instances字典缓存实例，但这个字典仅存在于单个进程的内存空间中。Windows下Python多进程默认用spawn模式启动子进程——每个子进程会启动全新的Python解释器，重新导入所有模块并初始化类，所以每个进程都会创建独立的_instances字典，自然生成不同的单例对象。

2. 手动运行与pytest的差异真相 #

你观察到的“手动运行时复用单例”其实是误解或代码巧合：

• Windows的spawn模式下，子进程不可能共享主进程的类实例字典。如果手动运行时看到id和value一致，要么是子进程重新创建了相同value的实例（id相同只是进程内内存地址的巧合，不同进程的id毫无关联），要么是你的手动测试代码中，单例实例是通过主进程序列化传递给子进程的（此时是副本，id必然不同，但value可能一致）。
• pytest运行时，测试框架的模块加载逻辑会强制重新加载测试模块，或者子进程启动时的模块上下文与手动运行不同，导致单例的_instances字典每次都被重新初始化，进而生成不同的实例（如果测试代码中初始化参数不同，value也会不一样）。

要实现真正的跨进程单例，必须借助跨进程共享的存储介质来保证只有一个实例被创建。以下是两种实用方案：

方案1：文件锁+共享内存（轻量高效） #

通过文件锁确保同一时间只有一个进程能初始化实例，并用共享内存存储实例状态，避免序列化开销：

import os
import multiprocessing
from multiprocessing import shared_memory
import fcntl

class CrossProcessSingleton:
    _SHARED_MEM_NAME = "singleton_shared_mem"
    _LOCK_FILE_PATH = "singleton.lock"
    _instance = None

    def __new__(cls, value=None):
        # 用文件锁保证全局唯一初始化
        with open(cls._LOCK_FILE_PATH, "w") as lock_file:
            fcntl.flock(lock_file, fcntl.LOCK_EX)
            
            try:
                # 尝试连接已存在的共享内存
                try:
                    existing_shm = shared_memory.SharedMemory(name=cls._SHARED_MEM_NAME)
                    # 从共享内存读取value（假设是整数，可根据需求调整序列化方式）
                    stored_value = int.from_bytes(existing_shm.buf, byteorder='little')
                    existing_shm.close()
                except FileNotFoundError:
                    # 共享内存不存在，创建新实例并写入共享内存
                    stored_value = value if value is not None else 0
                    shm = shared_memory.SharedMemory(name=cls._SHARED_MEM_NAME, create=True, size=4)
                    shm.buf[:4] = stored_value.to_bytes(4, byteorder='little')
                    shm.close()
                
                # 进程内复用实例
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance.value = stored_value
                return cls._instance
            finally:
                # 释放文件锁
                fcntl.flock(lock_file, fcntl.LOCK_UN)

    def __del__(self):
        # 仅主进程退出时清理共享内存和锁文件
        if multiprocessing.current_process().name == "MainProcess":
            try:
                shm = shared_memory.SharedMemory(name=self._SHARED_MEM_NAME)
                shm.close()
                shm.unlink()
                os.remove(self._LOCK_FILE_PATH)
            except Exception:
                # 忽略清理时的异常，避免影响进程退出
                pass

测试示例：

# test_multiprocessing.py
import multiprocessing
from your_module import CrossProcessSingleton

def worker():
    s = CrossProcessSingleton()
    print(f"Worker: value={s.value}, id={id(s)}")

def test_cross_process_singleton():
    s_main = CrossProcessSingleton(10)
    print(f"Main: value={s_main.value}, id={id(s_main)}")
    
    process = multiprocessing.Process(target=worker)
    process.start()
    process.join()
    
    s_main_again = CrossProcessSingleton()
    assert s_main_again.value == 10

方案2：用multiprocessing.Manager（实现简单） #

借助multiprocessing.Manager创建跨进程共享的字典，用来存储单例实例，适合快速实现：

from multiprocessing import Manager
import multiprocessing

class CrossProcessSingletonMeta(type):
    _manager = None
    _shared_instances = None

    def __call__(cls, *args, **kwargs):
        # 初始化跨进程共享字典
        if cls._manager is None:
            cls._manager = Manager()
            cls._shared_instances = cls._manager.dict()
        
        if cls not in cls._shared_instances:
            # 创建实例并存储到共享字典
            instance = super().__call__(*args, **kwargs)
            cls._shared_instances[cls] = instance
        return cls._shared_instances[cls]

class Singleton(metaclass=CrossProcessSingletonMeta):
    def __init__(self, value):
        self.value = value

注意：Manager创建的是代理对象，跨进程访问会有一定性能开销，适合对性能要求不高的场景。

临时适配pytest的小技巧 #

如果不需要跨进程单例，只是想在pytest中让每个测试进程内保持单例一致性，只需确保测试代码中，单例的初始化逻辑和手动运行一致即可——比如避免在测试函数外重复初始化单例，或者在测试前手动重置单例的_instances字典：

def test_singleton_in_process():
    # 重置单例状态（如果需要）
    SingletonMeta._instances.clear()
    s1 = Singleton(5)
    s2 = Singleton(5)
    assert id(s1) == id(s2)

内容的提问来源于stack exchange，提问作者Itération 122442