Python面向对象之单例模式的四大实现方法详解

# 问题：全局配置应该只有一个实例
# 如果每个模块都创建新的Config对象，配置就会不一致
# ❌ 多个实例——配置不一致
# config1 = AppConfig()  # debug=True
# config2 = AppConfig()  # debug=False —— 这是另一个配置了！
# ✅ 单例——只有一个实例
# config1 = AppConfig()  # 创建实例
# config2 = AppConfig()  # 返回同一个实例
# config1 is config2     # True —— 同一个对象

class Singleton:
    """单例——通过__new__控制实例创建"""
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialized = False
        return cls._instance
    def __init__(self, value=None):
        # ⚠️ __init__每次都会调用！需要防护
        if self._initialized:
            return
        self.value = value
        self._initialized = True
# 测试
s1 = Singleton("第一次")
s2 = Singleton("第二次")
print(s1 is s2)        # True —— 同一个实例
print(s1.value)        # 第一次 —— __init__只执行了一次
print(s2.value)        # 第一次

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 Database:
    """数据库连接——单例"""
    def __init__(self, connection_string="default"):
        self.connection_string = connection_string
        print(f"创建数据库连接: {connection_string}")
# 测试
db1 = Database("mysql://localhost/mydb")
db2 = Database("postgresql://localhost/testdb")
print(db1 is db2)                 # True
print(db1.connection_string)     # mysql://localhost/mydb
print(db2.connection_string)     # mysql://localhost/mydb
# ⚠️ 装饰器方式的缺点：
# Database现在是一个函数而不是类
print(type(Database))  # <class 'function'>
# isinstance检查不适用

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 Config(metaclass=SingletonMeta):
    """配置管理器——单例（通过元类）"""
    def __init__(self, debug=False):
        # 不需要_initialized防护——元类控制__init__只调用一次
        self.debug = debug
        self.settings = {}
        print(f"Config初始化: debug={debug}")
# 测试
c1 = Config(debug=True)
c2 = Config(debug=False)
print(c1 is c2)      # True
print(c1.debug)      # True —— 第一次初始化的值
print(c2.debug)      # True
# 💡 元类方式最优雅——类定义时就决定了单例行为
# __init__自动只执行一次

# 💡 Python的模块本身就是单例！
# 模块在第一次导入时执行，之后被缓存到sys.modules
# 这是最"Pythonic"的单例实现方式
# ===== config.py =====
"""
class AppConfig:
    def __init__(self):
        self.debug = False
        self.host = "localhost"
        self.port = 8080
    def set_debug(self, enabled):
        self.debug = enabled
# 在模块级别创建实例——这就是单例！
config = AppConfig()
"""
# ===== main.py =====
# from config import config
# 
# # 所有地方导入的都是同一个config对象
# config.set_debug(True)
# 
# # 另一个文件
# from config import config
# print(config.debug)  # True —— 同一个对象
# 💡 优点：简单、不需要任何特殊语法
# 💡 缺点：导入时即创建（不能延迟）、无法传参构造

import threading
from datetime import datetime
class Logger(metaclass=SingletonMeta):
    """日志管理器——全局唯一"""
    def __init__(self):
        self._lock = threading.Lock()
        self._handlers = []
        self._level = "INFO"
    def set_level(self, level):
        self._level = level
    def add_handler(self, handler):
        self._handlers.append(handler)
    def log(self, message, level="INFO"):
        """线程安全的日志记录"""
        with self._lock:
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
            log_entry = f"[{timestamp}] [{level}] {message}"
            # 输出到所有处理器
            for handler in self._handlers:
                handler(log_entry)
            # 默认输出到控制台
            if not self._handlers:
                print(log_entry)
# 使用——在任何地方获取同一个Logger
def some_function():
    logger = Logger()
    logger.log("函数执行中...")
def another_function():
    logger = Logger()
    logger.log("另一个函数执行中...", level="WARNING")
some_function()
another_function()

from threading import Lock
class ConnectionPool(metaclass=SingletonMeta):
    """数据库连接池——全局唯一"""
    def __init__(self, max_connections=10):
        self.max_connections = max_connections
        self._connections = []
        self._in_use = set()
        self._lock = Lock()
        print(f"连接池创建: 最大{max_connections}个连接")
    def get_connection(self):
        """获取一个连接"""
        with self._lock:
            if len(self._connections) < self.max_connections:
                conn = f"连接-{len(self._connections) + 1}"
                self._connections.append(conn)
            else:
                raise RuntimeError("连接池已满")
            self._in_use.add(conn)
            return conn
    def release_connection(self, conn):
        """释放连接"""
        with self._lock:
            self._in_use.discard(conn)
    def status(self):
        return {
            "total": len(self._connections),
            "in_use": len(self._in_use),
            "available": len(self._connections) - len(self._in_use),
        }
# 使用
pool = ConnectionPool(max_connections=5)
conn1 = pool.get_connection()
conn2 = pool.get_connection()
print(pool.status())  # {'total': 2, 'in_use': 2, 'available': 0}
pool.release_connection(conn1)
print(pool.status())  # {'total': 2, 'in_use': 1, 'available': 1}