python 6种方法实现单例模式
单例模式是一个软件的设计模式，为了保证一个类，无论调用多少次产生的实例对象，都是指向同一个内存地址，仅仅只有一个实例（只有一个对象）。
实现单例模式的手段有很多种，但总的原则是保证一个类只要实例化一个对象，下一次再实例的时候就直接返回这个对象，不再做实例化的操作。所以这里面的关键一点就是，如何判断这个类是否实例化过一个对象。
这里介绍两类方式：
- 一类是通过模块导入的方式；
- 一类是通过魔法方法判断的方式；
#基本原理： -第一类通过模块导入的方式，借用了模块导入时的底层原理实现。 -当一个模块（py文件）被导入时，首先会执行这个模块的代码，然后将这个模块的名称空间加载到内存。 -当这个模块第二次再被导入时，不会再执行该文件，而是直接在内存中找。 -于是，如果第一次导入模块，执行文件源代码时实例化了一个类，那再次导入的时候，就不会再实例化。 -第二类主要是基于类和元类实现，在'对象'的魔法方法中判断是否已经实例化过一个对象 -这类方式，根据实现的手法不同，又分为不同的方法，如： -通过类的绑定方法；通过元类；通过类下的__new__；通过装饰器（函数装饰器，类装饰器）实现等。
下面分别介绍这几种不同的实现方式，仅供参考实现思路，不做具体需求。
通过模块导入
#cls_singleton.py classFoo(object): pass instance=Foo() #test.py importcls_singleton obj1=cls_singleton.instance obj2=cls_singleton.instance print(obj1isobj2) #原理：模块第二次导入从内存找的机制
通过类的绑定方法
classStudent:
_instance=None #记录实例化对象
def__init__(self,name,age):
self.name=name
self.age=age
@classmethod
defget_singleton(cls,*args,**kwargs):
ifnotcls._instance:
cls._instance=cls(*args,**kwargs)
returncls._instance
stu1=Student.get_singleton('jack',18)
stu2=Student.get_singleton('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：类的绑定方法是第二种实例化对象的方式，
#第一次实例化的对象保存成类的数据属性_instance，
#第二次再实例化时，在get_singleton中判断已经有了实例对象，直接返回类的数据属性_instance
补充：这种方式实现的单例模式有一个明显的bug；bug的根源在于如果用户不通过绑定类的方法实例化对象，而是直接通过类名加括号实例化对象，那这样不再是单利模式了。
通过魔法方法__new__
classStudent:
_instance=None
def__init__(self,name,age):
self.name=name
self.age=age
def__new__(cls,*args,**kwargs):
#ifcls._instance:
#returncls._instance #有实例则直接返回
#else:
#cls._instance=super().__new__(cls) #没有实例则new一个并保存
#returncls._instance #这个返回是给是给init，再实例化一次，也没有关系
ifnotcls._instance: #这是简化的写法，上面注释的写法更容易提现判断思路
cls._instance=super().__new__(cls)
returncls._instance
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：和方法2类似，将判断的实现方式，从类的绑定方法中转移到类的__new__中
#归根结底都是判断类有没有实例，有则直接返回，无则实例化并保存到_instance中。
补充：这种方式可以近乎完美地实现单例模式，但是依然不够完美。不完美的地方在于没有考虑到并发的极端情况下，有可能多个线程同一时刻实例化对象。关于这一点的补充内容在本文的最后一节介绍(!!!进阶必会)。
通过元类**
classMymeta(type):
def__init__(cls,name,bases,dic):
super().__init__(name,bases,dic)
cls._instance=None #将记录类的实例对象的数据属性放在元类中自动定义了
def__call__(cls,*args,**kwargs): #此call会在类被调用（即实例化时触发）
ifcls._instance: #判断类有没有实例化对象
returncls._instance
else: #没有实例化对象时，控制类造空对象并初始化
obj=cls.__new__(cls,*args,**kwargs)
obj.__init__(*args,**kwargs)
cls._instance=obj #保存对象，下一次再实例化可以直接返回而不用再造对象
returnobj
classStudent(metaclass=Mymeta):
def__init__(self,name,age):
self.name=name
self.age=age
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：类定义时会调用元类下的__init__，类调用(实例化对象)时会触发元类下的__call__方法
#类定义时，给类新增一个空的数据属性，
#第一次实例化时，实例化之后就将这个对象赋值给类的数据属性；第二次再实例化时，直接返回类的这个数据属性
#和方式3的不同之处1：类的这个数据属性是放在元类中自动定义的，而不是在类中显示的定义的。
#和方式3的不同之处2：类调用时触发元类__call__方法判断是否有实例化对象，而不是在类的绑定方法中判断
函数装饰器
defsingleton(cls):
_instance_dict={} #采用字典，可以装饰多个类，控制多个类实现单例模式
definner(*args,**kwargs):
ifclsnotin_instance_dict:
_instance_dict[cls]=cls(*args,**kwargs)
return_instance_dict.get(cls)
returninner
@singleton
classStudent:
def__init__(self,name,age):
self.name=name
self.age=age
#def__new__(cls,*args,**kwargs): #将方法3的这部分代码搬到了函数装饰器中
#ifnotcls._instance:
#cls._instance=super().__new__(cls)
#returncls._instan
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
类装饰器
classSingleTon:
_instance_dict={}
def__init__(self,cls_name):
self.cls_name=cls_name
def__call__(self,*args,**kwargs):
ifself.cls_namenotinSingleTon._instance_dict:
SingleTon._instance_dict[self.cls_name]=self.cls_name(*args,**kwargs)
returnSingleTon._instance_dict.get(self.cls_name)
@SingleTon #这个语法糖相当于Student=SingleTon(Student),即Student是SingleTon的实例对象
classStudent:
def__init__(self,name,age):
self.name=name
self.age=age
stu1=Student('jack',18)
stu2=Student('jack',18)
print(stu1isstu2)
print(stu1.__dict__,stu2.__dict__)
#原理：在函数装饰器的思路上，将装饰器封装成类。
#程序执行到与语法糖时，会实例化一个Student对象，这个对象是SingleTon的对象。
#后面使用的Student本质上使用的是SingleTon的对象。
#所以使用Student('jack',18)来实例化对象，其实是在调用SingleTon的对象，会触发其__call__的执行
#所以就在__call__中，判断Student类有没有实例对象了。
!!!进阶必会
本部分主要是补充介绍多线程并发情况下，多线程高并发时，如果同时有多个线程同一时刻（极端条件下）事例化对象，那么就会出现多个对象，这就不再是单例模式了。
解决这个多线程并发带来的竞争问题，第一个想到的是加互斥锁，于是我们就用互斥锁的原理来解决这个问题。
解决的关键点，无非就是将具体示例化操作的部分加一把锁，这样同时来的多个线程就需要排队。
这样一来只有第一个抢到锁的线程实例化一个对象并保存在_instance中，同一时刻抢锁的其他线程再抢到锁后，不会进入这个判断ifnotcls._instance，直接把保存在_instance的对象返回了。这样就实现了多线程下的单例模式。
此时还有一个问题需要解决，后面所有再事例对象时都需要再次抢锁，这会大大降低执行效率。解决这个问题也很简单，直接在抢锁前，判断下是否有单例对象了，如果有就不再往下抢锁了（代码第11行判断存在的意义）。
importthreading classStudent: _instance=None #保存单例对象 _lock=threading.RLock() #锁 def__new__(cls,*args,**kwargs): ifcls._instance: #如果已经有单例了就不再去抢锁，避免IO等待 returncls._instance withcls._lock: #使用with语法，方便抢锁释放锁 ifnotcls._instance: cls._instance=super().__new__(cls,*args,**kwargs) returncls._instance
以上就是python6种方法实现单例模式的详细内容，更多关于python单例模式的资料请关注毛票票其它相关文章！