如何用 Python 实现单例模式

单例模式是一种常用的设计模式，旨在确保一个类只有一个实例，并为应用程序提供一个全局访问点。Python 语言中实现单例模式的方法有很多，每种方法都有其独特的优缺点和适用场景。以下将逐步介绍几种常见的单例模式实现方式，并且详细拆解每种变体的代码和应用场景。

1. 使用模块级变量实现单例模式

在 Python 中，模块本身就是单例的，因为当模块被导入时，Python 会将其缓存，并且同一模块不会被重新导入多次。基于这一特性，我们可以直接通过模块级变量来实现单例模式。

# singleton_module.py

class Singleton:
    def __init__(self):
        self.value = "This is a singleton instance."

singleton_instance = Singleton()

# main.py
from singleton_module import singleton_instance

print(singleton_instance.value)

在这个实现中，singleton_instance 是一个全局的模块级实例，无论在哪个模块中导入 singleton_module，singleton_instance 都会保持唯一性。这种方式简洁而有效，适合于简单场景。

2. 使用类变量来实现单例模式

可以使用类变量来实现单例模式，通过将实例保存在类变量中确保类的实例只能被创建一次。这种方式利用了 Python 类变量的特点。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

    def __init__(self, value):
        self.value = value

# 验证是否为单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "second instance"

在这里，__new__ 方法用于控制对象的创建。如果 _instance 是 None，则创建新对象并将其存储在 _instance 中。在之后的每次调用中都会返回已经存在的 _instance。

3. 使用装饰器实现单例模式

装饰器是一种优雅的 Python 语法，可以用来包装函数或者类。我们可以定义一个装饰器来为类提供单例模式的特性。

def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance

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

# 验证是否为单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

这个装饰器实现了对 Singleton 类的包装，并且确保 Singleton 只能创建一个实例。instances 字典用来存储每个被装饰类的实例，只有在实例不存在时才创建新的实例。

4. 使用元类实现单例模式

元类是一种更为高级的实现单例模式的方式。在 Python 中，元类控制类的创建过程，因此可以通过元类实现对实例创建的控制。

class SingletonMeta(type):
    _instances = {}

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

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

# 验证是否为单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

在这个实现中，SingletonMeta 是 Singleton 类的元类。通过重载 __call__ 方法，可以控制实例的创建过程，并确保只有一个实例存在。这种方式的灵活性很高，适用于需要更精细控制类行为的场景。

5. 使用 threading.Lock 来实现线程安全的单例模式

在多线程环境中，需要确保单例模式的实现是线程安全的。可以使用 threading.Lock 来实现这一点，从而防止多个线程同时创建实例。

import threading

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

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

    def __init__(self, value):
        self.value = value

# 验证是否为单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

这里使用了双重检查锁定的机制。_lock 确保了线程在进入创建实例的代码块时互斥，防止多个线程同时创建不同的实例。双重检查则减少了加锁带来的性能损耗，只有在 _instance 为 None 的情况下才会加锁创建实例。

6. 使用 __dict__ 属性共享来实现伪单例

在一些情况下，我们可能需要多个实例，但它们共享相同的数据。这种情况下可以通过 __dict__ 属性来实现伪单例。

class Borg:
    _shared_state = {}

    def __init__(self):
        self.__dict__ = self._shared_state

class Singleton(Borg):
    def __init__(self, value):
        super().__init__()
        self.value = value

# 验证是否为伪单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # False
print(singleton1.value)          # "second instance"

在这个实现中，Borg 类的所有实例共享同一个 __dict__ 属性，因此它们的状态是共享的。这种模式被称为 Borg 模式，与传统的单例模式不同的是，它允许多个实例，但这些实例共享同样的状态。

7. 使用 importlib 实现懒加载的单例模式

有时候单例模式的实例可能比较占用资源，只有在确实需要时才创建实例是一种更高效的方法。可以使用 importlib 模块来实现懒加载的单例模式。

import importlib

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

singleton_instance = None

def get_singleton_instance(value=None):
    global singleton_instance
    if singleton_instance is None:
        module = importlib.import_module(__name__)
        singleton_instance = getattr(module, 'Singleton')(value)
    return singleton_instance

# 验证是否为单例
singleton1 = get_singleton_instance("first instance")
singleton2 = get_singleton_instance("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

这个实现中，只有在调用 get_singleton_instance 函数时才会实际创建 Singleton 的实例。importlib 模块允许动态地导入模块，并获取其中的类和函数，从而实现懒加载。这种方式适合那些资源消耗较大的单例对象，只有在需要时才去初始化它们。

8. 使用 WeakValueDictionary 防止内存泄漏

在某些应用中，我们需要实现单例的行为，但又不希望对象被持久化引用，导致内存泄漏。可以使用 weakref.WeakValueDictionary 来实现。

import weakref

class Singleton:
    _instances = weakref.WeakValueDictionary()

    def __new__(cls, *args, **kwargs):
        if cls not in cls._instances:
            instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

    def __init__(self, value):
        self.value = value

# 验证是否为单例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

WeakValueDictionary 允许对对象的弱引用，当对象没有其他强引用时会被自动垃圾回收。这样可以确保单例对象在没有其他引用时被自动销毁，防止内存泄漏。

9. 使用基于 dataclass 的单例实现

在 Python 3.7+ 中引入了 dataclass，可以使用 dataclass 的方式实现单例模式。

from dataclasses import dataclass

@dataclass
class Singleton:
    value: str

    _instance = None

    @classmethod
    def get_instance(cls, value=None):
        if cls._instance is None:
            cls._instance = cls(value)
        return cls._instance

# 验证是否为单例
singleton1 = Singleton.get_instance("first instance")
singleton2 = Singleton.get_instance("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

dataclass 简化了类的定义，自动生成了 __init__ 方法等。这种实现方式保持了 dataclass 的简洁性，同时通过类方法 get_instance 来控制实例的创建。

10. 使用 functools.lru_cache 实现单例

Python 中的 functools.lru_cache 装饰器也可以用于实现单例模式，因为它可以缓存函数的返回值，保证函数在相同输入下只会执行一次。

from functools import lru_cache

@lru_cache(maxsize=None)
def get_singleton(value):
    class Singleton:
        def __init__(self, value):
            self.value = value

    return Singleton(value)

# 验证是否为单例
singleton1 = get_singleton("first instance")
singleton2 = get_singleton("second instance")

print(singleton1 is singleton2)  # True
print(singleton1.value)          # "first instance"

通过 lru_cache 实现了缓存功能，maxsize=None 意味着没有缓存大小的限制，只要输入的参数一致，返回的实例就是唯一的。这种方式适合那些函数式编程场景下的单例实现。

总结

以上介绍了在 Python 中实现单例模式的多种方法，每种方法都有其适用的场景和优缺点：

• 模块级变量实现适用于最简单的场景，代码易于理解且无需额外的同步控制。
• 使用类变量实现是一种经典的单例实现方式，适合于控制类实例化的场景。
• 使用装饰器是一种非常优雅的方式，适用于需要给多类增加单例特性的场景。
• 使用元类可以精细控制类的行为，是一种比较高级的实现方式，适用于对类的创建过程有更多需求的场合。
• 使用线程锁来确保线程安全适用于多线程环境，确保单例实例不会被重复创建。
• Borg 模式适用于需要共享状态但允许创建多个实例的场景，保持了类的灵活性。
• 懒加载单例适用于那些创建成本较高，只有在确实需要时才去创建的场景。
• 使用 WeakValueDictionary 可以有效防止内存泄漏，适用于短生命周期的单例对象。
• 基于 dataclass 的实现保留了代码的简洁性，同时实现了单例的特性。
• 使用 lru_cache 实现单例适用于函数式编程风格的应用场景，简洁且高效。

每种方法都有其优缺点和适用场景，根据项目的具体需求和代码风格选择合适的实现方式，可以让代码更加简洁、高效和易维护。