单例模式完整教程

class DatabaseManager:
    # 类加载时就创建唯一实例
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self, connection_string):
        # 初始化数据库连接池（只会执行一次）
        if not hasattr(self, 'initialized'):
            self.connection_string = connection_string
            self.pool = self._create_connection_pool()
            print(f"数据库连接池初始化完成: {connection_string}")
            self.initialized = True
    
    def _create_connection_pool(self):
        # 创建数据库连接池的实际逻辑
        return {"connections": 10, "max_connections": 20}
    
    def get_connection(self):
        # 从连接池获取连接
        return "数据库连接对象"

# 测试
if __name__ == "__main__":
    # 无论调用多少次，都只会创建一个实例
    db1 = DatabaseManager("mysql://localhost:3306/test")
    db2 = DatabaseManager("mysql://localhost:3306/prod")
    
    print(db1 is db2)  # 输出: True
    print(db1.connection_string)  # 输出: mysql://localhost:3306/test
    print(db2.connection_string)  # 输出: mysql://localhost:3306/test

class Logger:
    _instance = None
    
    def __init__(self, log_file="app.log"):
        self.log_file = log_file
        print(f"日志记录器初始化完成，日志文件: {log_file}")
    
    @classmethod
    def get_instance(cls, log_file="app.log"):
        # 只有在第一次调用时才创建实例
        if not cls._instance:
            cls._instance = cls(log_file)
        return cls._instance
    
    def log(self, message):
        print(f"[{self.log_file}] {message}")

# 测试
if __name__ == "__main__":
    logger1 = Logger.get_instance("app.log")
    logger2 = Logger.get_instance("error.log")
    
    print(logger1 is logger2)  # 输出: True
    logger1.log("这是一条日志")  # 输出: [app.log] 这是一条日志
    logger2.log("这是另一条日志")  # 输出: [app.log] 这是另一条日志

import threading

class ConfigManager:
    _instance = None
    _lock = threading.Lock()  # 线程锁
    
    def __init__(self):
        # 加载配置文件（只会执行一次）
        self.config = self._load_config()
        print("配置文件加载完成")
    
    def _load_config(self):
        # 实际的配置加载逻辑
        return {"debug": True, "port": 8000, "database": "mysql://localhost:3306/test"}
    
    @classmethod
    def get_instance(cls):
        # 第一次检查：如果实例已存在，直接返回，避免不必要的锁竞争
        if not cls._instance:
            # 获取锁，保证只有一个线程进入
            with cls._lock:
                # 第二次检查：防止多个线程同时通过第一次检查
                if not cls._instance:
                    cls._instance = cls()
        return cls._instance
    
    def get(self, key, default=None):
        return self.config.get(key, default)

# 多线程测试
def test_singleton():
    config = ConfigManager.get_instance()
    print(f"线程 {threading.get_ident()}: {id(config)}")

if __name__ == "__main__":
    # 创建10个线程同时获取实例
    threads = []
    for _ in range(10):
        t = threading.Thread(target=test_singleton)
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    # 所有线程都会得到同一个实例
    config1 = ConfigManager.get_instance()
    config2 = ConfigManager.get_instance()
    print(f"config1 is config2: {config1 is config2}")  # 输出: True