单例模式是一种常用的设计模式，旨在确保一个类只有一个实例，并为应用程序提供一个全局访问点。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实现单例适用于函数式编程风格的应用场景，简洁且高效。
