基于初始化参数缓存对象的多线程单例实现方案问询

现有ThreadedSingleton元类只能保证每个类返回唯一实例，但不区分初始化参数。我们需要实现一个按参数缓存实例的元类：传入相同参数（无论位置参数/关键字参数混合形式）时返回同一实例，不同参数返回不同实例，同时保留多线程安全。

核心思路 #

1. 参数标准化：将任意形式的传参（位置、关键字、混合）转换为唯一的标准化键，确保参数值相同则键相同
2. 嵌套缓存结构：用{类: {标准化参数键: 实例}}的结构存储不同类、不同参数组合的实例
3. 线程安全优化：为每个类分配独立锁，避免不同类之间的锁竞争，同时保留双重检查锁定（DCL）保证线程安全

实现代码 #

import inspect
import threading
from typing import Any, Tuple

class ParametricThreadedSingleton(type):
    """支持按参数缓存的多线程安全单例元类"""
    _instances: dict[type, dict[Tuple[Any, ...], Any]] = {}
    _locks: dict[type, threading.Lock] = {}

    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
        # 1. 标准化参数：将args和kwargs转换为包含所有参数（含默认值）的有序元组
        sig = inspect.signature(cls.__init__)
        bound_args = sig.bind(*args, **kwargs)
        bound_args.apply_defaults()
        # 提取参数值，按参数定义顺序排列
        param_key = tuple(bound_args.arguments.values())

        # 2. 双重检查锁定，保证线程安全
        if cls not in cls._instances:
            cls._locks[cls] = threading.Lock()
            cls._instances[cls] = {}
        if param_key not in cls._instances[cls]:
            with cls._locks[cls]:
                if param_key not in cls._instances[cls]:
                    cls._instances[cls][param_key] = super().__call__(*args, **kwargs)
        
        return cls._instances[cls][param_key]

示例使用与验证 #

定义示例类 #

class A(metaclass=ParametricThreadedSingleton):
    def __init__(self, a, b, c=3):
        self.a = a
        self.b = b
        self.c = c

验证逻辑 #

a1 = A(1, 2, 3)
a2 = A(a=1, b=2, c=3)
a3 = A(1, b=2, c=3)
a4 = A(1, b=2)
b1 = A(1, 2, 4)

# 验证相同参数（不同传参形式）返回同一实例
assert a1 is a2 is a3 is a4
# 验证不同参数返回不同实例
assert a1 is not b1

# 验证参数值一致
assert a1.c == 3
assert b1.c == 4

关键细节说明 #

• 参数标准化：通过inspect.signature解析__init__的参数签名，用bind和apply_defaults将任意传参转换为包含所有参数（包括默认值）的有序元组，彻底解决传参形式不同但值相同的问题
• 线程安全：每个类独立维护锁和实例缓存，避免跨类的锁竞争，双重检查锁定确保只有第一次创建实例时才会加锁，兼顾线程安全和性能
• 扩展性：支持任意带__init__参数的类，无需修改类本身的实现

内容的提问来源于stack exchange，提问作者omer mazig