单例模式的核心逻辑是限制类的实例化次数，通过私有化构造方法、提供静态访问方法的方式，保证全局只有唯一的实例对象。但在并发场景下，多个执行流同时访问实例获取方法时，很容易绕过实例判断的逻辑，创建出多个不同的实例，破坏单例的特性。
单例模式的基础实现
先看最基础的懒汉式单例实现，这是最容易在并发场景下出问题的版本，代码如下：
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
# 测试代码
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # 单线程下输出True，符合单例预期多线程环境下的表现与解决方案
多线程下的问题
在多线程场景中，如果多个线程同时调用Singleton()获取实例，可能出现两个线程同时判断_instance is None为True的情况，之后两个线程都会创建新的实例，最终导致单例失效。我们可以通过多线程测试代码复现这个问题：
import threading
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
# 模拟实例创建前的耗时操作，增大并发冲突概率
import time
time.sleep(0.01)
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
def test_singleton():
s = Singleton()
print(f"线程{threading.current_thread().name} 实例id: {id(s)}")
threads = []
for i in range(5):
t = threading.Thread(target=test_singleton)
threads.append(t)
t.start()
for t in threads:
t.join()运行上述代码后，很大概率会出现多个不同的实例id，说明单例已经被破坏。
线程安全的单例实现方案
加锁方案
最直接的方式是对实例创建的逻辑加线程锁，保证同一时间只有一个线程能执行实例判断和创建的逻辑：
import threading
class Singleton:
_instance = None
_lock = threading.Lock()
def __new__(cls, *args, **kwargs):
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance双重检查锁方案
加锁方案每次获取实例都需要加锁，会带来性能损耗，双重检查锁可以减少锁的竞争，只在实例未创建时加锁：
import threading
class Singleton:
_instance = None
_lock = threading.Lock()
def __new__(cls, *args, **kwargs):
if cls._instance is None:
with cls._lock:
# 再次判断，避免多个线程同时通过第一层判断后重复创建
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance基于模块天然单例的方案
Python的模块在导入时只会执行一次，因此可以直接将实例定义在模块中，天然实现线程安全的单例：
# singleton.py 模块
class _Singleton:
pass
singleton_instance = _Singleton()
# 其他模块导入使用
from singleton import singleton_instance多进程环境下的表现与解决方案
多进程下的问题
多进程场景下，每个进程都有独立的内存空间，单例类的类变量是每个进程独立的，因此即使线程安全的单例实现，在不同进程中也无法共享实例，每个进程都会创建自己的单例实例，单例特性失效。
我们可以通过多进程代码测试这个问题：
import multiprocessing
import threading
class Singleton:
_instance = None
_lock = threading.Lock()
def __new__(cls, *args, **kwargs):
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
def test_singleton():
s = Singleton()
print(f"进程{ multiprocessing.current_process().name} 实例id: {id(s)}")
if __name__ == "__main__":
processes = []
for i in range(3):
p = multiprocessing.Process(target=test_singleton)
processes.append(p)
p.start()
for p in processes:
p.join()运行后可以看到三个进程输出的实例id完全不同，说明每个进程都有自己的单例实例。
多进程下的单例实现思路
多进程下要实现全局唯一的单例，需要借助进程间共享的存储来实现，常见的方案有两种：
- 使用共享内存或者第三方存储：比如将单例实例存储在Redis、数据库等所有进程都能访问的共享存储中，获取实例时先从共享存储中查询，不存在则创建并写入，同时需要处理并发创建的问题。
- 使用multiprocessing的Manager对象：Python的multiprocessing模块提供了Manager，可以创建进程间共享的变量，基于Manager实现单例：
import multiprocessing
def init_singleton(manager_dict):
# 初始化共享的单例存储
if "singleton_instance" not in manager_dict:
manager_dict["singleton_instance"] = object()
def get_singleton(manager_dict):
return manager_dict["singleton_instance"]
if __name__ == "__main__":
manager = multiprocessing.Manager()
shared_dict = manager.dict()
init_singleton(shared_dict)
def test_process(shared_dict):
s = get_singleton(shared_dict)
print(f"进程{ multiprocessing.current_process().name} 实例id: {id(s)}")
processes = []
for i in range(3):
p = multiprocessing.Process(target=test_process, args=(shared_dict,))
processes.append(p)
p.start()
for p in processes:
p.join()不同场景下的单例选择建议
如果应用是单进程多线程架构，使用双重检查锁或者模块天然单例的方案即可；如果是多进程架构，需要根据实际需求选择共享存储的方案，避免盲目使用默认的单例实现。另外如果单例需要存储状态，多进程场景下还需要考虑状态同步的问题，避免不同进程的单例状态不一致。
Singleton_pattern多线程多进程线程安全进程安全修改时间：2026-06-06 15:45:19