Python中如何实现单例模式？单例模式在多线程下是否安全？

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock: # 添加锁，保证线程安全
                if cls._instance is None: # Double Check Lock
                    cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

    def __init__(self, value):
        # 避免每次调用都重新初始化
        if not hasattr(self, 'initialized'):
            self.value = value
            self.initialized = True

# 使用示例
s1 = Singleton(10)
s2 = Singleton(20) # value=20 不会生效，因为实例已经创建

print(s1.value) # 输出 10
print(s2.value) # 输出 10
print(s1 is s2) # 输出 True

import threading

def singleton(cls):
    _instance = {}
    _lock = threading.Lock()

    def _singleton(*args, **kwargs):
        if cls not in _instance:
            with _lock:
                if cls not in _instance:
                    _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]
    return _singleton

@singleton
class MyClass:
    def __init__(self, value):
        self.value = value

m1 = MyClass(10)
m2 = MyClass(20)
print(m1.value) # 输出 10
print(m2.value) # 输出 10
print(m1 is m2) # 输出 True

import threading

class SingletonMeta(type):
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

m1 = MyClass(10)
m2 = MyClass(20)
print(m1.value) # 输出 10
print(m2.value) # 输出 10
print(m1 is m2) # 输出 True

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

    def __init__(self, value):
        if not hasattr(self, 'initialized'):
            self.value = value
            self.initialized = True

    def __reduce__(self):
        # 阻止序列化/反序列化创建实例
        return (self.__class__, ())

# 使用示例
s1 = Singleton(10)
import pickle
# 尝试通过pickle反序列化创建新的实例
try:
    s2 = pickle.loads(pickle.dumps(s1))
    print(s1 is s2)
except Exception as e:
    print(f"反序列化失败: {e}")