Python 单例模式：从原理到实战

★

本文为 Python 进阶系列第 9 篇，面向运维开发者与编程初学者。读完本文，你将理解单例模式的本质，掌握四种实现方式，并能在实际项目中正确使用。

一、什么是单例模式？

单例模式（Singleton Pattern） 是最常用的设计模式之一。它的核心思想只有一句话：

★

保证一个类在整个程序生命周期内，只有一个实例存在。

生活类比

想象公司里的打印机：无论哪个部门的员工来打印，用的都是同一台机器，不可能每来一个人就新买一台。单例模式做的事情完全相同——无论你在代码中"创建"多少次，拿到的永远是那同一个对象。

用代码感受一下问题

不使用单例时，每次实例化都是一个全新对象：

classDatabaseConnection:def__init__(self):        print("建立数据库连接...")  # 实际项目中这里会消耗大量资源db1 = DatabaseConnection()  # 建立数据库连接...db2 = DatabaseConnection()  # 建立数据库连接...print(db1 is db2)   # False：两个完全不同的对象print(id(db1) == id(db2))  # False

如果程序里 100 个地方都 DatabaseConnection()，就会建立 100 条连接，内存和资源被白白浪费。单例模式正是为解决这类问题而生的。

二、四种实现方式

方式一：模块级单例（最 Pythonic）

Python 的模块在第一次被导入时执行，之后再次导入会直接复用缓存，天然是单例。

# config.pyclass_Config:def__init__(self):        self.debug = False        self.db_host = "localhost"        self.db_port = 5432# 模块加载时创建唯一实例，外部直接导入使用config = _Config()

# 其他文件中使用from config import configconfig.db_host = "10.0.0.1"# 修改会全局生效

验证：

from config import config as afrom config import config as bprint(a is b)  # True：永远是同一个对象

适用场景： 配置对象、常量集合。简单直接，无需额外代码，是 Python 中最推荐的轻量级单例写法。

方式二：__new__ 方法实现

通过重写类的 __new__ 方法，控制实例的创建过程。

classSingleton:    _instance = None# 类变量，存储唯一实例def__new__(cls, *args, **kwargs):if cls._instance isNone:            cls._instance = super().__new__(cls)return cls._instance  # 无论调用多少次，返回的都是同一个对象def__init__(self, value=None):        self.value = values1 = Singleton("first")s2 = Singleton("second")print(s1 is s2)           # Trueprint(id(s1) == id(s2))   # True

★

⚠️ 注意：__init__ 每次都会执行

__new__ 保证了实例唯一，但 Python 每次调用类时都会执行 __init__，导致属性被覆盖：

print(s1.value)  # second（被第二次 __init__ 覆盖了！）

如需防止重复初始化，加一个标志位：

classSingleton:    _instance = None    _initialized = Falsedef__new__(cls, *args, **kwargs):if cls._instance isNone:            cls._instance = super().__new__(cls)return cls._instancedef__init__(self, name="default"):if self._initialized:return# 已初始化则直接跳过        self.name = name        self._initialized = Trueobj1 = Singleton("first")obj2 = Singleton("second")print(obj1.name)  # first（不会被覆盖）print(obj2.name)  # first（同一个对象）

方式三：装饰器实现（推荐）

用装饰器将"保证唯一实例"的逻辑与业务类彻底分离，复用性最强。

from functools import wrapsdefsingleton(cls):    instances = {}    @wraps(cls)defget_instance(*args, **kwargs):if cls notin instances:            instances[cls] = cls(*args, **kwargs)return instances[cls]return get_instance@singletonclassDatabaseConnection:def__init__(self, host="localhost", port=5432):        self.host = host        self.port = port        print(f"创建数据库连接: {host}:{port}")db1 = DatabaseConnection("192.168.1.1", 5432)  # 创建数据库连接: 192.168.1.1:5432db2 = DatabaseConnection("192.168.1.1", 5432)  # 不会再次打印，直接返回缓存print(db1 is db2)  # True

优势： 一个 @singleton 装饰器可以复用到任意类上，零侵入业务逻辑。

方式四：元类（Metaclass）实现

元类是"类的类"，控制类的创建行为。适合框架级代码，灵活性和扩展性最强。

classSingletonMeta(type):    _instances = {}def__call__(cls, *args, **kwargs):if cls notin cls._instances:            cls._instances[cls] = super().__call__(*args, **kwargs)return cls._instances[cls]classAppConfig(metaclass=SingletonMeta):def__init__(self):        self.settings = {}defset(self, key, value):        self.settings[key] = valuedefget(self, key, default=None):return self.settings.get(key, default)cfg1 = AppConfig()cfg2 = AppConfig()cfg1.set("env", "production")print(cfg1 is cfg2)              # Trueprint(cfg2.get("env"))           # production（共享同一份数据）

★

💡 初学者提示：元类是 Python 的高级特性，理解起来需要一定基础。如果你还不熟悉元类，优先掌握装饰器方式，两者效果完全等价，装饰器更直观。

四种方式横向对比

三、线程安全单例

在多线程环境（Web 服务、并发脚本）中，多个线程可能同时判断 _instance is None，导致创建多个实例。解决方案是双重检查锁：

import threadingclassThreadSafeSingleton:    _instance = None    _lock = threading.Lock()  # 类级别锁，所有实例共享def__new__(cls, *args, **kwargs):if cls._instance isNone:          # 第一次检查：避免每次都加锁（性能优化）with cls._lock:                # 加锁，保证同一时刻只有一个线程进入if cls._instance isNone:  # 第二次检查：防止锁等待期间其他线程已创建                    cls._instance = super().__new__(cls)return cls._instance

验证线程安全性：

results = []defcreate_instance():    obj = ThreadSafeSingleton()    results.append(id(obj))# 10 个线程同时创建threads = [threading.Thread(target=create_instance) for _ in range(10)]for t in threads:    t.start()for t in threads:    t.join()print(len(set(results)) == 1)  # True：所有线程拿到的都是同一个实例

★

💡 运维开发特别注意：运维平台、监控系统、后台服务中大量使用多线程，数据库连接池、配置中心等单例对象必须使用线程安全实现，否则高并发下会出现难以复现的诡异 bug。

四、实际使用场景与完整示例

场景一：日志管理器

整个应用共享一个日志实例，避免多个 Handler 重复输出日志。

import loggingfrom functools import wrapsdefsingleton(cls):    instances = {}    @wraps(cls)defget_instance(*args, **kwargs):if cls notin instances:            instances[cls] = cls(*args, **kwargs)return instances[cls]return get_instance@singletonclassLogManager:def__init__(self):        self.logger = logging.getLogger("AppLogger")        self.logger.setLevel(logging.DEBUG)        handler = logging.StreamHandler()        handler.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))ifnot self.logger.handlers:            self.logger.addHandler(handler)definfo(self, msg):        self.logger.info(msg)defwarning(self, msg):        self.logger.warning(msg)deferror(self, msg):        self.logger.error(msg)# 任何模块中调用，拿到的都是同一个 LogManagerlog = LogManager()log.info("服务启动成功")log.warning("内存使用率超过 80%")# 验证单例log2 = LogManager()print(log is log2)  # True

场景二：配置中心

运维脚本读取配置文件一次，全局共享，避免重复 I/O。

classSingletonMeta(type):    _instances = {}def__call__(cls, *args, **kwargs):if cls notin cls._instances:            cls._instances[cls] = super().__call__(*args, **kwargs)return cls._instances[cls]classConfigCenter(metaclass=SingletonMeta):def__init__(self):# 实际项目中这里从文件或远程加载配置        self._config = {"db_host": "localhost","db_port": 5432,"cache_ttl": 300,        }defget(self, key, default=None):return self._config.get(key, default)defset(self, key, value):        self._config[key] = value# 模块 A 中修改配置c1 = ConfigCenter()c1.set("db_host", "10.0.0.1")# 模块 B 中读取配置，自动获得最新值c2 = ConfigCenter()print(c2.get("db_host"))  # 10.0.0.1（全局共享）print(c1 is c2)           # True

五、单例模式的优势与局限

优势

① 节省资源：数据库连接、文件句柄、网络连接等重量级对象只创建一次，避免重复开销。

② 全局访问：任何模块都能获取同一个实例，天然实现了全局状态共享，无需手动传参。

③ 避免冲突：多处写入同一个配置、同一个日志文件时，单例保证操作的唯一入口，减少竞态条件。

局限与注意事项

① 测试困难：单例持有全局状态，单元测试时上一个测试的状态可能污染下一个。解决方案是测试时提供重置方法或使用依赖注入。

② 隐式耦合：代码各处直接调用单例，依赖关系不明显，重构时容易出问题。大型项目建议通过依赖注入框架管理。

③ 慎用滥用：单例本质是全局变量的封装，过度使用会让代码难以追踪状态变化。只在真正需要"全局唯一"时使用。

六、核心知识点总结

一句话记忆：单例模式 = 全局唯一实例 + 统一访问入口，用于管理共享资源。

七、实战作业

实现一个数据库连接池单例，要求：

1. 线程安全
2. 初始化时创建固定数量的连接（用字符串模拟）
3. 提供 get_connection() 和 release_connection() 方法

# 提示：结合 ThreadSafeSingleton + collections.deque 实现连接队列import threadingimport collectionsclassConnectionPool:    _instance = None    _lock = threading.Lock()def__new__(cls, *args, **kwargs):if cls._instance isNone:with cls._lock:if cls._instance isNone:                    cls._instance = super().__new__(cls)return cls._instancedef__init__(self, size=5):# 防止重复初始化if hasattr(self, "_initialized"):return        self._pool = collections.deque(            [f"Connection-{i}"for i in range(size)]        )        self._initialized = Truedefget_connection(self):if self._pool:return self._pool.popleft()raise RuntimeError("连接池已耗尽")defrelease_connection(self, conn):        self._pool.append(conn)

★

下一篇文章预告： 全局变量与返回值——那些你不知道的坑，敬请期待！