Python-FAQ-单例模式

1 需求

---

2 接口

---

3 示例

---

4 参考资料

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。在 Python 中，实现单例模式有多种方式，下面介绍几种常见的实现方法及其优缺点。

1. 使用模块（Pythonic 方式）

Python 的模块天然就是单例的，因为模块在第一次导入时会被创建并缓存，后续导入会直接使用缓存的实例。

实现示例：

# singleton.py
class Singleton:
    def __init__(self):
        self.value = None

    def do_something(self):
        print(f"Singleton instance: {id(self)}, value: {self.value}")

# 创建唯一实例
singleton_instance = Singleton()

使用方式：

from singleton import singleton_instance

singleton_instance.value = "Hello"
singleton_instance.do_something()  # 输出: Singleton instance: 1405... value: Hello

# 其他模块导入的是同一个实例
from another_module import another_function
another_function()  # 输出相同的实例 ID

优点：

• 实现简单，无需额外代码
• 线程安全
• 天然延迟初始化（模块首次导入时创建实例）

缺点：

• 无法延迟初始化（除非通过函数包装）
• 不够灵活（例如无法传入参数）

2. 使用类方法（经典实现）

通过类方法控制实例的创建，确保只有一个实例被创建。

实现示例：

class Singleton:
    _instance = None

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

    def __init__(self):
        if self._instance is not None:
            raise RuntimeError("Use get_instance() to create the instance")
        # 初始化代码

使用方式：

s1 = Singleton.get_instance()
s2 = Singleton.get_instance()
print(s1 is s2)  # 输出: True

优点：

• 延迟初始化（首次调用 get_instance() 时创建实例）
• 明确的创建接口

缺点：

• 每次调用都需要通过类方法，不够简洁
• 多线程环境下可能创建多个实例（需加锁）

3. 使用元类（高级实现）

元类可以控制类的创建过程，确保类只有一个实例。

实现示例：

class SingletonMeta(type):
    _instances = {}

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

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        # 初始化代码
        pass

使用方式：

s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # 输出: True

优点：

• 透明的实例化（直接通过类名创建实例）
• 支持继承
• 线程安全（元类的 __call__ 方法在多线程环境下是原子操作）

缺点：

• 实现复杂，理解门槛较高
• 不支持延迟初始化（类定义时即创建实例）

4. 使用装饰器

通过装饰器包装类，确保只有一个实例。

实现示例：

def singleton(cls):
    instances = {}

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

    return wrapper

@singleton
class MySingleton:
    def __init__(self):
        # 初始化代码
        pass

使用方式：

s1 = MySingleton()
s2 = MySingleton()
print(s1 is s2)  # 输出: True

优点：

• 简单易用
• 支持参数传递

缺点：

• 不支持继承
• 不支持延迟初始化（除非通过内部函数包装）

5. 懒汉式单例（延迟初始化）

结合类方法和锁机制，实现线程安全的延迟初始化。

实现示例：

import threading

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

    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            with cls._lock:
                # 双重检查锁定
                if cls._instance is None:
                    cls._instance = cls()
        return cls._instance

优点：

• 线程安全
• 延迟初始化

缺点：

• 实现复杂
• 每次调用都需要加锁，性能开销略高

单例模式的应用场景

1. 日志系统：全局唯一的日志记录器，避免重复配置。
2. 数据库连接池：共享同一个连接池实例，避免资源浪费。
3. 配置管理：全局配置中心，确保所有模块使用相同配置。
4. 资源管理器：如文件系统、网络连接等，需要统一管理的资源。

注意事项

• 测试困难：单例可能影响单元测试的独立性，需谨慎设计。
• 多线程 / 多进程：需考虑线程安全和进程间通信问题。
• 反模式争议：单例可能导致代码耦合度高，应根据场景合理使用。

选择哪种实现方式取决于具体需求，推荐优先使用模块级单例或元类方式，它们更符合 Python 的设计哲学且实现简洁。