深入剖析Python的单例模式实现
一、引言
单例模式是一种常见的设计模式，它限制一个类只能生成一个实例。在Python开发中，我们该如何实现单例模式呢？本文将通过一个简单的例子，使用Python的元类来实现一个线程安全的单例类，并比较说明使用装饰器实现单例的优劣。
单例模式看起来简单，但是想要做到完全线程安全并支持子类继承，还有一定的难度。本文将从单例模式的概念和应用场景开始，一步步分析线程安全的单例类该如何设计，加锁来保证线程安全等。
二、单例的应用场景
-
系统只需要一个实例对象，比如配置类、日志、工具类等。使用单例可以直接保证全局只存在一个实例。
-
控制资源访问，比如一个硬件资源只允许一个进程访问，或者打印机只允许一个任务执行打印操作。
-
频繁创建和销毁实例会带来较高的系统开销，使用单例可以减少内存占用和性能消耗。比如任务池、连接池等。
-
想确保一个类只有一个可见的实例，并提供一个全局访问点，如线程池、缓存、会话对象等。
-
当类状态需要频繁保存和恢复时，可以让类成为单例，避免每次获取实例后都要恢复状态的操作。
-
在面向对象中，如果有状态共享的需求，可以将共享状态和逻辑封装在一个单例类中。
-
单例可以简化代码，从而降低维护成本。在不需要多个实例的情况下，单例可以消除判断逻辑。
如下是一些伪代码的单例DEMO
配置类
配置类信息在程序运行期间仅需要一个实例，使用单例模式可以保证全局唯一:
class Config(metaclass=SingletonMetaCls):
def __init__(self):
self.config = {'timeout':100， 'port':8000}
# 访问配置
print(Config().config)
2. 日志类
日志类也只需要一个实例输出日志信息即可:
class Logger(metaclass=SingletonMetaCls):
def __init__(self):
print("初始化logger")
def log(self， msg):
print(f"log: {msg}")
# 使用
Logger().log("测试日志")
任务池
控制任务池的资源个数，只初始化指定数量的连接:
class TaskPool(metaclass=SingletonMetaCls):
def __init__(self， size=10):
print(f"初始化{size}个任务到池中")
# 初始化一个10大小的任务池
pool = TaskPool()
总之，任何只需要一个实例、不保存状态的工具/帮助类，你需要限制实例个数的场景，都可以考虑使用单例模式实现。
三、单例的实现
重写 __new__ 方法
Python 的 new 对象不像java等其他语言一样，一些初学者可能会误认为 __init__ 方法是构造对象，实则不是，__init__方法是初始化对象属性，而__new__ 方法才是真正构造类实例对象。因此我们可以通过 重写__new__方法 并在方法内部添加判断逻辑，来限制一个类只创建一个实例。
class Singleton(object):
_instance = None
def __new__(cls, *args, **kwargs):
# 重写 __new__ 实现单例
if not cls._instance:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
def __init__(self):
# 初始化实例属性
self.demo_name = "Singleton Demo"
s1 = Singleton()
s2 = Singleton()
print("s1 demo_name", s1.demo_name)
print("s2 demo_name", s2.demo_name)
print("s1", s1)
print("s2", s2)
print("s1 is s2", s1 is s2)
print("s1 == s2", s1 == s2)
>>> out
s1 demo_name Singleton Demo
s2 demo_name Singleton Demo
s1 <__main__.Singleton object at 0x1051dcb80>
s2 <__main__.Singleton object at 0x1051dcb80>
s1 is s2 True
s1 == s2 True
通过重写 __new__ 实现单例，就可以实现最简单的单例模式。可以发现创建的对象的内存地址都是一样的。
上面的实现模式属于懒汉模式，还有一种叫做饿汉模式。先简单介绍下这两种模式概念。
懒汉模式
懒汉模式是等到需要才创建实例，比如:
一个游戏需要读取玩家存档数据的类，如果玩家没有存档,就不需要创建该类的实例，等玩家第一次存档时再实例化该类，读取并保存游戏状态。这种情况下使用懒汉模式更合适，不会提前占用内存资源。
饿汉模式
饿汉模式是提前创建实例，比如:
一个数据库连接池类，系统启动时就需要初始化一个指定大小的连接池，以备后续使用。这里需要饿汉模式提前创建并准备好数据库连接池，否则后面需要数据库连接时会出现延迟。
-
懒汉是按需创建，节省资源
-
饿汉是准备实例，避免后续延迟
饿汉代码实现
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Hui
# @Desc: { 单例DEMO }
# @Date: 2023/08/22 09:27
class BaseSingleton(object):
_instance = None
@classmethod
def instance(cls):
if not cls._instance:
cls._instance = cls()
return cls._instance
class Singleton(BaseSingleton):
# _instance = Singleton() 这是错误的语法
def __new__(cls, *args, **kwargs):
if not cls._instance:
BaseSingleton.instance()
return cls._instance
def __init__(self):
# 初始化实例属性
self.demo_name = "Singleton Demo"
s1 = Singleton.instance()
s2 = Singleton.instance()
s3 = Singleton()
s4 = Singleton()
print("s1", s1)
print("s2", s2)
print("s3", s3)
print("s4", s4)
print("s1 is s2", s1 is s2)
print("s2 is s3", s2 is s3)
print("s3 is s4", s3 is s4)
>>> out
s1 <__main__.BaseSingleton object at 0x1051dcf70>
s2 <__main__.BaseSingleton object at 0x1051dcf70>
s3 <__main__.BaseSingleton object at 0x1051dcf70>
s4 <__main__.BaseSingleton object at 0x1051dcf70>
s1 is s2 True
s2 is s3 True
s3 is s4 True
python的饿汉模式，不能直接在类中构造自身对象，如下是错误的写法
class Singleton(BaseSingleton):
_instance = Singleton() # 这是错误的语法
因此这里通过添加一个静态方法 instance() 来实现饿汉单例模式，但感觉有点不太像，就是要在new 对象前先通过 instance() 方法初始化下对象实例，到后面在其他模块使用已经存在的实例即可。但有时候就是想，instance() 是单例，Singleton() 这种new 对象不是，那就不要重写 __new__ 方法即可。因为有时候new对象想重新初始化属性。
虽然通过重写
__new__方法，实现了单例模式，但不够完善，在并发的情况下还是会创建多个实例，属于线程不安全，因此还是需要改造下，这里先展示并发问题，具体改造看下面装饰器的写法。
class Singleton(object):
_instance = None
def __new__(cls, *args, **kwargs):
# 重写 __new__ 实现单例
if not cls._instance:
print("new instance")
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
def __init__(self):
# 初始化实例属性
self.demo_name = "Singleton Demo"
def create_obj(num):
s = Singleton()
print(f"s{num}", s)
# 多线程测试并发
with ThreadPoolExecutor() as pool:
for i in range(3, 10):
pool.submit(create_obj, i)
测试效果，这个要多运行几遍才有概率复现
可以发现，多线程的打印是凌乱的，但已经可以证明有2个线程创建了两实例对象 new instance，对象的内存地址也不一样。这是由于 if not cls._instance: 操作是非原子性操作的导致的并发问题。
装饰器写法
重写 __new__ 方法还是比较容易懂，但不太方便使用，每个类都要重写这个方法就很麻烦，逻辑都是一样的，因此我上面抽了一个 BaseSingleton 类来做，通过继承来复用代码。还有一种方式就是通过装饰器来实现单例，把共用的逻辑放到装饰器中做，然后再处理下并发问题。
def singleton(cls_obj):
"""单例装饰器"""
_instance_dic = {}
_instance_lock = threading.Lock()
@functools.wraps(cls_obj)
def wrapper(*args, **kwargs):
if cls_obj in _instance_dic:
# 实例字典中存在则直接返回
return _instance_dic.get(cls_obj)
with _instance_lock: # 互斥锁，防止多线程竞争，导致创建多实例
if cls_obj not in _instance_dic:
# 实例字典中没有，则创建对象实例，存入字典中
_instance_dic[cls_obj] = cls_obj(*args, **kwargs)
return _instance_dic.get(cls_obj)
return wrapper
由于 if cls_obj not in _instance_dic 判断是非原子性操作故而会引发多线程并发问题。
它大致会转换成以下字节码指令执行:
- 加载
_instance_dic到栈顶
Copy code
LOAD_GLOBAL 0 (_instance_dic)
- 加载
cls_obj到栈顶
Copy code
LOAD_FAST 0 (cls_obj)
- 调用
__contains__方法检查是否在字典中
Copy code
CONTAINS_OP
- 根据返回值进行跳转
Copy code
POP_JUMP_IF_FALSE
如果cls_obj不在_instance_dic中,就会跳转到target位置,也就是if块内的代码。
可以看到校验是否在字典中是在多个指令中完成，不是一个原子操作。
在多线程环境下，如果多个线程同时执行到这里，都可能会通过校验,然后创建实例添加到字典中，从而导致线程不安全。
故而在装饰器中通过线程的互斥锁来解决并发问题，然后通过字典来判断是否存在类的实例对象，存在直接返回，不存在创建对象实例存入字典中来达到单例的效果。
@singleton
class Foo(object):
def __init__(self):
self.bar = "bar"
@singleton
class Demo(object):
def __init__(self):
self.demo_name = "singleton_demo"
f1 = Foo()
f2 = Foo()
print(f1)
print(f2)
print("f1 is f2", f1 is f2)
d1 = Demo()
d2 = Demo()
print(d1)
print(d2)
print("d1 is d2", d1 is d2)
>>> out
<__main__.Foo object at 0x102f56c70>
<__main__.Foo object at 0x102f56c70>
f1 is f2 True
<__main__.Demo object at 0x102f56d60>
<__main__.Demo object at 0x102f56d60>
d1 is d2 True
并发安全验证
@singleton
class Foo(object):
def __init__(self):
self.bar = "bar"
def two_bar(self):
return self.bar * 2
def create_obj(num):
foo = Foo()
print(f"foo{num}", foo)
return foo
with ThreadPoolExecutor() as pool:
for i in range(10):
pool.submit(create_obj, i)
ok，对象实例都是 <main.Foo object at 0x1016ed700>， 大家可以多运行几次，加了锁不会出现多个实例对象了。
这里发现被装饰的类都实现了单例模式，接下来我们一探究竟，在装饰器内部打印些东西，看看其工作原理。
def singleton(cls_obj):
"""单例装饰器"""
print("cls_obj", cls_obj)
_instance_dic = {}
_instance_lock = threading.Lock()
@functools.wraps(cls_obj)
def wrapper(*args, **kwargs):
if cls_obj in _instance_dic:
# 实例字典中存在则直接返回
return _instance_dic.get(cls_obj)
with _instance_lock: # 互斥锁，防止多线程竞争，导致创建多实例
if cls_obj not in _instance_dic:
# 实例字典中没有，则创建对象实例，存入字典中
_instance_dic[cls_obj] = cls_obj(*args, **kwargs)
print("_instance_dic", _instance_dic, "\n")
return _instance_dic.get(cls_obj)
return wrapper
@singleton
class Foo(object):
def __init__(self):
self.bar = "bar"
@singleton
class Demo(object):
def __init__(self):
self.demo_name = "singleton_demo"
f1 = Foo()
f2 = Foo()
print(f1)
print(f2)
print("f1 is f2", f1 is f2)
d1 = Demo()
d2 = Demo()
print(d1)
print(d2)
print("d1 is d2", d1 is d2)
模块在初始化的时候，其实就会把类初始化形成类对象，注意不是类的实例对象。
-
装饰器的原理就是python解释器识别到 @singleton 的语法糖时自动把类对象的引用传递给 singleton 装饰器函数
-
此时装饰器会返回一个新的函数对象（wrapper）出去，把类对象重新赋值了
- Foo = singleton(Foo) = wrapper
- Demo = singleton(Demo) = wrapper
-
到创建对象实例时，Foo() 实则变成了是调用函数 wrapper() 来创建对象
-
然后每个类都维护了一份 _instance = {} 实例字典，来确保这个类创建的对象只有一份
- Key 是类对象，eg：Foo、Demo
- Value 是类的实例对象，eg：Foo()，Demo()
可能大家会不了解类对象的概念，可以先看看我这篇文章 你真的了解Python中的类class? - 掘金 然后再回来看就更容易看懂了。
但装饰器实现的单例模式装饰方便、代码简洁，但是破坏了类的类型，把类变成了函数，导致编写代码的时候没有提示，也不知道有什么属性与方法，所以实际使用起来及其不方便。
接下来就是引出另一种写法，元类实现单例。
元类写法
元类是一种非常晦涩的知识点，一般场景都用不上，但知道元类的原理，后面需要用到时，可以帮助你更好的抽象与封装。
元类就是创建 类对象的类，type 就是元类
可以先了解下元类的知识点：追溯Python类的鼻祖——元类 - 掘金
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Hui
# @Desc: { 元类模块 }
# @Date: 2022/11/26 16:43
import threading
class SingletonMetaCls(type):
""" 单例元类 """
_instance_lock = threading.Lock()
def __init__(cls， *args， **kwargs):
cls._instance = None
super().__init__(*args， **kwargs)
def __call__(cls， *args， **kwargs):
if cls._instance:
# 存在实例对象直接返回，减少锁竞争，提高性能
return cls._instance
with cls._instance_lock:
if not cls._instance:
cls._instance = super().__call__(*args， **kwargs)
return cls._instance
使用单例元类进行单例的封装会比装饰器的更好一些，装饰器封装的单例，再实际使用的过程中不太方便，IDE一些开发工具不知道这个类有什么属性，元类就不会，继承也可以实现单例。
class Foo(metaclass=SingletonMetaCls):
def __init__(self):
self.bar = "bar"
def tow_bar(self):
return self.bar * 2
foo1 = Foo()
foo2 = Foo()
print("foo1 is foo2", foo1 is foo2)
>>> out
foo1 is foo2 True
继承案例
class Foo(metaclass=SingletonMetaCls):
def __init__(self):
self.bar = "bar"
def tow_bar(self):
return self.bar * 2
foo1 = Foo()
foo2 = Foo()
print("foo1 is foo2", foo1 is foo2)
print("foo1 is foo2", foo1 is foo2)
class Demo(Foo):
def __init__(self):
self.bar = "demo_bar"
demo1 = Demo()
demo2 = Demo()
print("demo1 is demo2", demo1 is demo2)
print("demo2 two_bar", demo2.tow_bar())
>>> out
foo1 is foo2 True
foo2 two_bar barbar
demo1 is demo2 True
demo2 two_bar demo_bardemo_bar
元类实现原理
-
加载Foo、Demo等类时，发现指定了元类 metaclass=SingletonMetaCls， 则会让指定的元类来帮助创建类对象
-
此时 SingletonMetaCls 会调用__init__ 来创建类对象，然后通过super() 让 type 来创建类对象
- type(类名, 父类元组, 类属性字典)
- 并动态加了个 cls._instance 属性
-
Foo()、Demo()，创建实例对象时，是Foo、Demo类对象触发了()，所以调用 call() 魔法属性来构造对象实例，存到cls._instance中
-
下次再创建实例对象，则是先判断是否有，有直接返回，没有则创建
可以打印一些信息来验证
import threading
class SingletonMetaCls(type):
""" 单例元类 """
_instance_lock = threading.Lock()
def __init__(cls, *args, **kwargs):
cls._instance = None
print("SingletonMetaCls __init__", cls)
print("args", args)
print("kwargs", kwargs)
super().__init__(*args, **kwargs)
def _init_instance(cls, *args, **kwargs):
if cls._instance:
# 存在实例对象直接返回，减少锁竞争，提高性能
print("cls._instance", cls._instance)
return cls._instance
with cls._instance_lock:
if cls._instance is None:
cls._instance = super().__call__(*args, **kwargs)
return cls._instance
def __call__(cls, *args, **kwargs):
print("SingletonMetaCls __call__ cur cls", cls)
instance = cls._init_instance()
reinit = kwargs.get("reinit", True)
if reinit:
# 默认都重新初始化单例对象属性
instance.__init__(*args, **kwargs)
return instance
from py_tools.meta_cls import SingletonMetaCls
class Foo(metaclass=SingletonMetaCls):
def __init__(self):
print("Foo __init__")
self.bar = "bar"
def __new__(cls, *args, **kwargs):
print("Foo __new__")
return super().__new__(cls, *args, **kwargs)
def tow_bar(self):
return self.bar * 2
# foo1 = Foo()
# foo2 = Foo()
# print("foo1 is foo2", foo1 is foo2)
# print("foo2 two_bar", foo2.tow_bar())
class Demo(Foo):
def __init__(self):
self.bar = "demo_bar"
模块加载时就会走元类的__init__
SingletonMetaCls __init__
args ('Foo', (), {'__module__': '__main__', '__qualname__': 'Foo', '__init__': , '__new__': , 'tow_bar': , '__classcell__': })
kwargs {}
SingletonMetaCls __init__
args ('Demo', (,), {'__module__': '__main__', '__qualname__': 'Demo', '__init__': })
kwargs {}
| 看看new对象的时候的打印信息
class Foo(metaclass=SingletonMetaCls):
def __init__(self):
print("Foo __init__")
self.bar = "bar"
def __new__(cls, *args, **kwargs):
print("Foo __new__")
return super().__new__(cls, *args, **kwargs)
def tow_bar(self):
return self.bar * 2
foo1 = Foo()
foo2 = Foo()
print("foo1 is foo2", foo1 is foo2)
输出信息如下
SingletonMetaCls __init__
args ('Foo', (), {'__module__': '__main__', '__qualname__': 'Foo', '__init__': , '__new__': , 'tow_bar': , '__classcell__': })
kwargs {}
SingletonMetaCls __call__ cur cls
Foo __new__
Foo __init__
Foo __init__
SingletonMetaCls __call__ cur cls
cls._instance <__main__.Foo object at 0x1049b3f70>
Foo __init__
foo1 is foo2 True
| 可以发现跟我上面的说的一致，这里引出了好多魔法属性来验证，可以先看看。
四、总结
-
类重写 new 易懂，但每个类都要重写太冗余了
- 故抽出 BaseSingleton 基类，复用逻辑通过 instance() 来实现单例（推荐）
- 如果要构造实例属性会有点不太方便
-
装饰器写法也是复用了创建单例的逻辑，装饰起来方便、简洁
- 但实际使用装饰过的类不方便，没有类属性提示
-
元类的写法会有点难与绕，实际使用起来方便，多继承也实现了单例（推荐）
- 使用起来和平常使用类没有区别
- 还可以通过reinit参数来控制是否重新初始化实例对象属性
-
通过线程的互斥锁来解决并发问题
- 双重判断来减少锁竞争，提高性能
-
当然还有其他的方式实现单例，例如通过Python的模块导入，来保证只会创建一个实例
如果你对Python感兴趣，想要学习python，这里给大家分享一份Python全套学习资料，都是我自己学习时整理的，希望可以帮到你，一起加油！
有需要的小伙伴，可以点击下方链接免费领取或者V扫描下方二维码免费领取
Python全套学习资料
1️⃣零基础入门
① 学习路线
对于从来没有接触过Python的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
② 路线对应学习视频
还有很多适合0基础入门的学习视频，有了这些视频，轻轻松松上手Python~
③练习题
每节视频课后，都有对应的练习题哦，可以检验学习成果哈哈！
2️⃣国内外Python书籍、文档
① 文档和书籍资料
3️⃣Python工具包+项目源码合集
①Python工具包
学习Python常用的开发软件都在这里了！每个都有详细的安装教程，保证你可以安装成功哦！
②Python实战案例
光学理论是没用的，要学会跟着一起敲代码，动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。100+实战案例源码等你来拿！
③Python小游戏源码
如果觉得上面的实战案例有点枯燥，可以试试自己用Python编写小游戏，让你的学习过程中增添一点趣味！
4️⃣Python面试题
我们学会了Python之后，有了技能就可以出去找工作啦！下面这些面试题是都来自阿里、腾讯、字节等一线互联网大厂，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
上述所有资料 ⚡️ ，朋友们如果有需要的，可以扫描下方二维码免费领取
