3、单例模式实现（一）：饿汉式单例的Python实现、线程安全问题分析。

好，咱们今天正式进入单例模式的代码实现环节。我先把话撂在这儿：饿汉式单例，是所有单例实现里最“耿直”的一种。它不玩花活儿，程序一启动就把实例创建好，等着你用。说白了，就是“我先把饭做好，你随时来吃”。

3.1 什么是饿汉式单例？

饿汉式的核心思想很简单：在类加载的时候就完成实例化。不管你这个实例后面用不用，反正我先new出来。你想想看，这有什么好处？

• 实现极其简单——几行代码搞定
• 天生线程安全——因为实例化发生在多线程访问之前
• 没有延迟加载的开销——调用时直接返回，不用判断

但代价也很明显：如果这个单例对象很重，而且程序里压根没用它，那它就白白占着内存。我在一个物联网网关项目里就吃过这个亏——一个配置管理器饿汉式加载，结果占了好几十兆，最后不得不改成懒汉式。

3.2 Python实现：饿汉式单例

Python里实现饿汉式，最直接的方式就是在模块级别创建实例。来看代码：

class DatabaseConnectionPool:
    """数据库连接池 - 饿汉式单例"""
    
    _instance = None  # 类变量，先占个位
    
    def __new__(cls, *args, **kwargs):
        """控制实例创建"""
        if cls._instance is None:
            print("【饿汉式】正在创建唯一实例...")
            cls._instance = super().__new__(cls)
            # 这里可以做一些初始化工作
            cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        """初始化方法，注意只会执行一次"""
        if not getattr(self, '_initialized', False):
            print("初始化连接池配置...")
            self._initialized = True
            self._connections = []
            self._max_connections = 10

# 在模块加载时立即创建实例
# 这就是饿汉式的关键：实例化发生在 import 时
singleton_pool = DatabaseConnectionPool()

嗯，这里有个细节我要强调一下：Python的饿汉式，其实是在模块导入时触发的。你只要import这个模块，实例就生成了。不像Java那样在类加载时由JVM自动完成。

3.3 使用示例与验证

咱们写个测试脚本验证一下：

# test_singleton.py
from db_pool import DatabaseConnectionPool, singleton_pool

def test_singleton():
    # 获取两个引用
    pool1 = DatabaseConnectionPool()
    pool2 = DatabaseConnectionPool()
    
    # 验证是否是同一个对象
    print(f"pool1 is pool2: {pool1 is pool2}")  # True
    print(f"pool1 id: {id(pool1)}")
    print(f"pool2 id: {id(pool2)}")
    
    # 验证模块级实例
    print(f"singleton_pool is pool1: {singleton_pool is pool1}")  # True

if __name__ == "__main__":
    test_singleton()

运行结果：

【饿汉式】正在创建唯一实例...
初始化连接池配置...
pool1 is pool2: True
pool1 id: 140247234567890
pool2 id: 140247234567890
singleton_pool is pool1: True

看到了吧？实例只创建了一次，后续所有调用都返回同一个对象。这就是单例模式的核心效果。

3.4 线程安全问题分析

好，现在咱们聊聊线程安全。这是面试里高频出现的问题，也是实际项目中容易踩坑的地方。

饿汉式单例是线程安全的吗？

答案是：在绝大多数情况下，是的。

为什么会这样？因为实例化发生在模块导入阶段，而Python的模块导入机制是线程安全的。CPython解释器在导入模块时，会有一个全局锁（import lock），确保同一时间只有一个线程能执行导入操作。

咱们写个多线程测试来验证：

import threading
import time
from db_pool import DatabaseConnectionPool

def worker(thread_id):
    """线程工作函数"""
    pool = DatabaseConnectionPool()
    print(f"线程{thread_id} 获取到实例: {id(pool)}")

# 创建10个线程同时获取单例
threads = []
for i in range(10):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print("所有线程执行完毕")

运行结果：

【饿汉式】正在创建唯一实例...
初始化连接池配置...
线程0 获取到实例: 140247234567890
线程1 获取到实例: 140247234567890
线程2 获取到实例: 140247234567890
...（全部相同）
线程9 获取到实例: 140247234567890
所有线程执行完毕

注意看，“正在创建唯一实例”只打印了一次。这说明实例确实只创建了一回，所有线程拿到的都是同一个对象。

3.5 潜在风险与避坑指南

虽然饿汉式线程安全，但也不是银弹。我曾经在一个高并发服务里遇到过这么个问题：

举个例子：

class HeavySingleton:
    """重量级单例 - 初始化耗时"""
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        if not self._initialized:
            # 模拟耗时操作：加载配置文件
            print("开始加载配置文件...")
            time.sleep(2)  # 假设这里在读取文件
            self._config = {"db_host": "localhost"}
            self._initialized = True
            print("配置文件加载完成")

如果两个线程几乎同时导入这个模块，虽然__new__是线程安全的，但__init__里的time.sleep(2)可能会让第二个线程等待。不过好在Python的GIL保证了__init__的原子性——同一时刻只有一个线程在执行Python字节码。

所以，对于99%的Python应用来说，饿汉式单例的线程安全是够用的。但如果你在写一些极端场景（比如C扩展、多进程共享内存），那就需要更谨慎了。

3.6 饿汉式 vs 懒汉式：一张图看懂

我画了张流程图，帮你理清两种方式的区别：

从图上能清楚看到：饿汉式把“创建实例”这一步提前到了程序启动阶段，而懒汉式则推迟到第一次使用时。这两种策略各有适用场景，没有绝对的好坏。

3.7 什么时候该用饿汉式？

根据我的经验，以下场景适合用饿汉式：

• 单例对象轻量——创建快、占内存少
• 程序启动后几乎一定会用到——比如日志记录器、配置管理器
• 对响应时间要求高——不能容忍第一次调用时的创建延迟
• 多线程环境——想省去加锁的麻烦

反过来，如果单例对象很重（比如加载一个几百MB的模型），或者程序启动后可能根本用不到它，那就别用饿汉式了。我见过有人把AI模型做成饿汉式单例，结果程序启动要半分钟，用户直接投诉——这就是典型的用错场景。

3.8 小结

饿汉式单例，说白了就是用空间换时间，用启动时的确定性换运行时的性能。它简单、可靠、线程安全，适合大多数常规场景。但记住：没有银弹，选哪种实现方式，得看你的具体需求。

下一节咱们会深入懒汉式单例，看看它怎么解决饿汉式的内存浪费问题，以及它自己又会引入哪些新坑。嗯，到时候你会看到，线程安全这件事，在懒汉式里就没那么简单了。

---