python 单例模式:
方法一:
py模块就是天然的单例模式,在其他模块直接导入实例;
class Singleton:
def __init__(self):
pass
def func(self):
pass
# 在其他模块直接导入实例 sln;
sln = Singleton()
# 删除该类,防止在其他模块再次实例化
del Singleton
方法二:
使用装饰器,该方法实现的单例只会实例化1次,第2次不会再实例化,而是使用已有的实例;
而且可以加入线程锁,保证线程安全;
from threading import Lock
# 一:先写个实现单例功能的装饰器
# 1.实现个装饰器
def singleton(cls):
# 2.创建个字段用来存放类的实例
_instance = {}
_lock = Lock()
def wrapper(*args, **kwargs):
# 线程安全
with _lock:
# 3.检测字典中是否有保存类的实例
if cls not in _instance.keys():
# 4.没有实例便创建实例并保存到字典中
_instance[cls] = cls(*args, **kwargs)
return _instance[cls] # 5.返回实例
return wrapper # 6.返回方法
# 二:导入装饰器,装饰在类上
@singleton
class ClassDemo:
def __init__(self, n):
print(f'参数{n},正在实例化对象...,')
if __name__ == '__main__':
d1 = ClassDemo(10086) # 只会实例化1次
d2 = ClassDemo(10010) # 第2次不会再次进行实例化,而是引用已有的实例
print(id(d1))
print(id(d2))
# 执行结果:=========================
# 参数10086,正在实例化对象...,
# 2364709639728
# 2364709639728
方法三:
__new__() 方法,此方法第1次实例化时会创建1个新的实例并存储在类的属性里,第2次实例化时不会创建新的实例,而是使用已有的实例,但是会重新为实例初始化参数,省去创建和销毁实例的开销;
from threading import Lock
# Python 在实例化对象的时候类会调用 __new__() 创建一个对象,
# 如果类没有实现__new__()方法,那么会调用 Object 的 __new__() 的方法;
# 然后再调用 __init__() 方法进行初始化;
class Singleton_(object):
def __init__(self, x):
self.x = x
print('实例化对象...', x)
# 1.重写 __new__() 方法
def __new__(cls, *args, **kwargs):
# 线程锁
_lock = Lock()
with _lock:
# 2.检查是类是否有 _instance 属性
if not hasattr(cls, '_instance'):
# 3.没有 _instance 属性便调用父类__new__()方法创建个对象赋值给 _instance 属性
cls._instance = super().__new__(cls)
return cls._instance # 4. 返回对象实例
if __name__ == '__main__':
s1 = Singleton_(1) # 第1次实例化时会创建1个新的实例并存储再类的属性里
s2 = Singleton_(2) # 第2次实例化时不会创建新的实例,而是使用已有的实例,但是会重新为实例初始化参数
s3 = Singleton_(3)
s1.func()
s2.func()
s3.func()
print(id(s1))
print(id(s2))
print(id(s3))
# 执行结果:============================
# 创建对象...
# 初始化对象... 1
# 不创建对象...
# 初始化对象... 2
# 不创建对象...
# 初始化对象... 3
# 实例属性: 3
# 实例属性: 3
# 实例属性: 3
# 2747330237272
# 2747330237272
# 2747330237272