python怎么实现单例,python单例模式应用场景

　　简单来说，singleton模式就是保证在一个项目的整个生命周期中只有一个实例，并且在项目的任何地方使用都是同一个实例。

　　singleton模式虽然简单，但是也有一些门道，很少有人知道这些门道。

　　边界情况

　　Python中实现singleton模式的方法有很多种，我之前最常用的是下面这种写法。

　　classSingleton(object):

　　_ instance=无

　　def__new__(cls，*args，**kw):

　　ifcls。_ instanceisNone:

　　cls。_ instance=对象。__new__(cls，*args，**kw)

　　returncls的编写有两个问题。_instance。

　　1.在实例化singleton模式对应的类时，无法传入参数，因此将上面的代码扩展为以下形式。

　　classSingleton(object):

　　_ instance=无

　　def__new__(cls，*args，**kw):

　　ifcls。_ instanceisNone:

　　cls。_ instance=对象。__new__(cls，*args，**kw)

　　returncls。_实例

　　def__init(self，x，y):

　　self.x=x

　　self.y=y

　　S=Singleton(1，2)将抛出typeerror:object。_ _ new _ _()只接受一个参数(类型为instant)错误。

　　2.当多个线程实例化Singleton类时，可能会创建多个实例，因为很有可能多个线程会判断cls。_instance同时为None，从而进入前期。

　　在初始化实例的代码中。

　　基于同步锁实现单例

　　首先考虑上述实现遇到的第二个问题。

　　由于在多线程的情况下会有边界条件和参数的多个实例，所以可以使用同步锁来解决多线程的冲突。

　　导入线程

　　#同步锁定

　　defsynchronous_lock(func):

　　defwrapper(*args，**kwargs):

　　通过阅读。锁():

　　returnfunc(*args，**kwarg

　　s)

　　returnwrapper

　　classSingleton(object):

　　instance=None

　　@synchronous_lock

　　def__new__(cls,*args,**kwargs):

　　ifcls.instanceisNone:

　　cls.instance=object.__new__(cls,*args,**kwargs)

　　returncls.instance上述代码中通过threading.Lock()将单例化方法同步化，这样在面对多个线程时也不会出现创建多个实例的情况，可以简单试验一下。

defworker():
　　s=Singleton()
　　print(id(s))
　　deftest():
　　task=[]
　　foriinrange(10):
　　t=threading.Thread(target=worker)
　　task.append(t)
　　foriintask:
　　i.start()
　　foriintask:
　　i.join()
　　test()

　　更优的方法

　　加了同步锁之后，除了无法传入参数外，已经没有什么大问题了，但是否有更优的解决方法呢？单例模式是否有可以接受参数的实现方式？

defsingleton(cls):
　　cls.__new_original__=cls.__new__
　　@functools.wraps(cls.__new__)
　　defsingleton_new(cls,*args,**kwargs):
　　it=cls.__dict__.get('__it__')
　　ifitisnotNone:
　　returnit
　　
　　cls.__it__=it=cls.__new_original__(cls,*args,**kwargs)
　　it.__init_original__(*args,**kwargs)
　　returnit
　　cls.__new__=singleton_new
　　cls.__init_original__=cls.__init__
　　cls.__init__=object.__init__
　　returncls
　　
　　@singleton
　　classFoo(object):
　　def__new__(cls,*args,**kwargs):
　　cls.x=10
　　returnobject.__new__(cls)
　　def__init__(self,x,y):
　　assertself.x==10
　　self.x=x
　　self.y=y

　　__init__方法，使用singleton_new方法进行类的实例化，在singleton_new方法中，先判断类的属性中是否存在__it__属性，以此来判断

　　是否要创建新的实例，如果要创建，则调用类原本的__new__方法完成实例化并调用原本的__init__方法将参数传递给当前类，从而完成单

　　例模式的目的。

　　这种方法让单例类可以接受对应的参数但面对多线程同时实例化还是可能会出现多个实例，此时加上线程同步锁则可。

defsingleton(cls):
　　cls.__new_original__=cls.__new__
　　@functools.wraps(cls.__new__)
　　defsingleton_new(cls,*args,**kwargs):
　　#同步锁
　　withthreading.Lock():
　　it=cls.__dict__.get('__it__')
　　ifitisnotNone:
　　returnit
　　
　　cls.__it__=it=cls.__new_original__(cls,*args,**kwargs)
　　it.__init_original__(*args,**kwargs)
　　returnit
　　cls.__new__=singleton_new
　　cls.__init_original__=cls.__init__
　　cls.__init__=object.__init__
　　returncls

　　如果一个项目不需要使用线程相关机制，只是在单例化这里使用了线程锁，这其实不是必要的，它会拖慢项目的运行速度。

　　阅读CPython线程模块相关的源码，你会发现，Python一开始时并没有初始化线程相关的环境，只有当你使用theading库相关功能时，

　　才会调用PyEval_InitThreads方法初始化多线程相关的环境，代码片段如下（我省略了很多不相关代码）。

staticPyObject*
　　thread_PyThread_start_new_thread(PyObject*self,PyObject*fargs)
　　{
　　PyObject*func,*args,*keyw=NULL;
　　structbootstate*boot;
　　unsignedlongident;
　　
　　//初始化多线程环境，解释器默认不初始化，只有用户使用时，才初始化。
　　PyEval_InitThreads();/*Starttheinterpreter'sthread-awareness*/
　　//创建线程
　　ident=PyThread_start_new_thread(t_bootstrap,(void*)boot);
　　
　　//返回线程id
　　returnPyLong_FromUnsignedLong(ident);
　　}

　　因为多线程环境会启动GIL锁相关的逻辑，这会影响Python程序运行速度。很多简单的Python程序并不需要使用多线程，此时不需要初始化线程相关的环境，Python程序在没有GIL锁的情况下会运行的更快。

　　如果你的项目中不会涉及多线程操作，那么就没有使用有同步锁来实现单例模式。

　　结尾

　　互联网中有很多Python实现单例模式的文章，你只需要从多线程下是否可以保证单实例以及单例化时是否可以传入初始参数两点来判断

　　相应的实现方法则可。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。