Python中的单例模式的三种落成形式的优缺点及优化,Python中的单例情势的二种达成情势的及优化

单例形式

单例格局(Singleton
Pattern)
是一种常用的软件设计形式,该形式的首要目标是保险某叁个类唯有2个实例存在。当您期望在全方位体系中,有个别类只好出现3个实例时,单例对象就会派上用场。

譬如说,有个别服务器程序的铺排音信寄存在一个文件中,客户端通过七个 AppConfig
的类来读取配置文件的音讯。如果在程序运转时期,有广大地方都亟需运用安排文件的内容,也正是说,诸多地点都急需创设AppConfig 对象的实例,那就导致系统中设有多个 AppConfig
的实例对象,而那般会严重浪费内存财富,越发是在布局文件内容大多的情事下。事实上,类似
AppConfig 那样的类,大家期望在程序运转时期只设有二个实例对象。

在 Python 中,我们能够用二种主意来落到实处单例形式

 

Python中的单例情势的二种达成格局的利弊及优化,python优缺点

福寿齐天单例方式的几种艺术

单例情势

单例形式(Singleton
Pattern)
是一种常用的软件设计格局,该情势的器重目标是保障某三个类唯有多个实例存在。当你指望在一切系统中,某些类只可以出现1个实例时,单例对象就会派上用场。

比方说,有些服务器程序的安插新闻寄存在2个文本中,客户端通过二个 AppConfig
的类来读取配置文件的信息。如若在程序运营时期,有众多地点都亟需采取安插文件的始末,也等于说,繁多地方都亟待创制AppConfig 对象的实例,那就导致系统中留存七个 AppConfig
的实例对象,而这么会严重浪费内部存储器财富,尤其是在陈设文件内容多数的情形下。事实上,类似
AppConfig 那样的类,大家盼望在程序运行时期只存在三个实例对象。

在 Python 中,大家得以用各种办法来促成单例格局

 

1.使用模块

其实,Python
的模块正是天生的单例情势
,因为模块在第1回导入时,会生成 .pyc 文件,当首回导入时,就能平素加载 .pyc 文件,而不会重复推行模块代码。因而,大家只需把相关的函数和数量定义在二个模块中,就足以获得3个单例对象了。假设大家确实想要贰个单例类,能够思考这么做:

mysingleton.py

class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()

将下面的代码保存在文件 mysingleton.py 中,要利用时,直接在此外文件中程导弹入此文件中的对象,这几个目的便是单例情势的对象

from a import singleton

 

贯彻单例格局的三种办法

二.应用装饰器

def Singleton(cls):
    _instance = {}

    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]

    return _singleton


@Singleton
class A(object):
    a = 1

    def __init__(self, x=0):
        self.x = x


a1 = A(2)
a2 = A(3)

 

 

壹.利用模块

其实,Python
的模块便是先天的单例方式
,因为模块在率先次导入时,会生成 .pyc 文件,当第三遍导入时,就能够直接加载 .pyc 文件,而不会重新实践模块代码。因而,大家只需把有关的函数和多少定义在1个模块中,就能够收获1个单例对象了。如若大家实在想要贰个单例类,能够设想那样做:

mysingleton.py

class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()

将地点的代码保存在文书 mysingleton.py 中,要使用时,直接在其他文件中程导弹入此文件中的对象,这么些目的就是单例方式的目的

from a import singleton

 

 

3.使用类

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

一般景况,我们感觉这么就成功了单例方式,可是那样当使用二十四线程时会存在难点

 

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

import threading

def task(arg):
    obj = Singleton.instance()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()

程序推行后,打字与印刷结果如下:

<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>

看起来也不曾难点,那是因为实施进程过快,若是在init方法中有局地IO操作,就能意识标题了,下边大家经过time.sleep模拟

咱俩在地方__init__办法中插足以下代码:

    def __init__(self):
        import time
        time.sleep(1)

重复实行顺序后,结果如下

<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>

主题素材出现了!根据以上办法开创的单例,不或许支撑二10二十四线程

 

化解办法:加锁!未加锁部分出现试行,加锁部分串行实践,速度降低,不过保障了数额安全

import time
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def task(arg):
    obj = Singleton.instance()
    print(obj)
for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)

 

打字与印刷结果如下:

<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>

那样就诸多了,可是依然有一点不成难题,便是当程序推行时,实践了time.sleep(20)后,上边实例化对象时,此时曾经是单例形式了,但大家依旧加了锁,那样不太好,再展开局地优化,把intance方法,改成下边包车型大巴如此就行:

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

如此,一个方可支撑二十多线程的单例格局就成功了

88bifa必发唯一官网 188bifa必发唯一官网 2

import time
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def task(arg):
    obj = Singleton.instance()
    print(obj)
for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)

一体化代码

 

那种措施完结的单例情势,使用时会有限定,现在实例化必须通过 obj = Singleton.instance()

借使用 obj=Singleton()
,那种办法拿到的不是单例

 

2.使用类

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

诚如意况,大家以为这么就落成了单例形式,不过这么当使用拾贰线程时会存在难点

 

class Singleton(object):

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

import threading

def task(arg):
    obj = Singleton.instance()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()

程序推行后,打字与印刷结果如下:

<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>

看起来也从不难题,那是因为执行进程过快,假如在init方法中有一对IO操作,就能够开掘难题了,上边大家经过time.sleep模拟

大家在上头__init__方式中进入以下代码:

    def __init__(self):
        import time
        time.sleep(1)

重新施行顺序后,结果如下

<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>

标题出现了!根据上述措施创设的单例,无法支撑十二线程

 

消除办法:加锁!未加锁部分出现试行,加锁部分串行试行,速度下滑,可是保障了数据安全

import time
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        time.sleep(1)

    @classmethod
    def instance(cls, *args, **kwargs):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def task(arg):
    obj = Singleton.instance()
    print(obj)
for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)

 

打字与印刷结果如下:

<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>

那般就差不离了,可是依旧有一点小标题,便是当程序实践时,执行了time.sleep(20)后,下边实例化对象时,此时一度是单例形式了,但我们依旧加了锁,那样不太好,再拓展部分优化,把intance方法,改成上边包车型大巴这么就行:

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

这么,八个方可协助10贰线程的单例方式就完毕了

88bifa必发唯一官网 3import
time import threading class Singleton(object): _instance_lock =
threading.Lock() def __init__(self): time.sleep(1) @classmethod def
instance(cls, *args, **kwargs): if not hasattr(Singleton,
“_instance”): with Singleton._instance_lock: if not
hasattr(Singleton, “_instance”): Singleton._instance =
Singleton(*args, **kwargs) return Singleton._instance def task(arg):
obj = Singleton.instance() print(obj) for i in range(10): t =
threading.Thread(target=task,args=[i,]88bifa必发唯一官网,) t.start() time.sleep(20) obj =
Singleton.instance() print(obj) 完整代码

 

那种办法贯彻的单例格局,使用时会有限制,将来实例化必须经过 obj = Singleton.instance()

万一用 obj=Singleton()
,那种办法获得的不是单例

 

4.基于__new__措施落成(推荐使用,方便)

通过上边例子,我们得以知道,当大家兑现单例时,为了保障线程安全须求在里面加入锁

笔者们明白,当大家实例化一个目的时,是西子行了类的__new__方法(大家没写时,私下认可调用object.__new__),实例化对象;然后再试行类的__init__方法,对这些目的实行开始化,全体大家得以依附这几个,达成单例情势

import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass


    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)  
        return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)

def task(arg):
    obj = Singleton()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()

打字与印刷结果如下:

<__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>

 

动用那种艺术的单例方式,未来实例化对象时,和日常实例化对象的法子同样 obj = Singleton() 

 

3.基于__new__主意达成

通过上面例子,大家能够知道,当大家兑现单例时,为了保证线程安全要求在里面参与锁

笔者们明白,当大家实例化贰个目的时,是先执行了类的__new__方法(我们没写时,暗中同意调用object.__new__),实例化对象;然后再实施类的__init__方法,对那个目的举办开端化,全数大家得以依靠这么些,落成单例形式

import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass


    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls, *args, **kwargs)
        return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)

def task(arg):
    obj = Singleton()
    print(obj)

for i in range(10):
    t = threading.Thread(target=task,args=[i,])
    t.start()

打字与印刷结果如下:

<__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>
<__main__.Singleton object at 0x038B33D0>

 

应用那种办法的单例格局,现在实例化对象时,和经常实例化对象的章程1致 obj = Singleton() 

 

五.基于metaclass形式落成

四.基于metaclass情势完毕

有关文化

"""
1.类由type创建,创建类时,type的__init__方法自动执行,类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
2.对象由类创建,创建对象时,类的__init__方法自动执行,对象()执行类的 __call__ 方法
"""

例子:

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        pass

obj = Foo()
# 执行type的 __call__ 方法,调用 Foo类(是type的对象)的 __new__方法,用于创建对象,然后调用 Foo类(是type的对象)的 __init__方法,用于对对象初始化。

obj()    # 执行Foo的 __call__ 方法    

 

元类的利用

class SingletonType(type):
    def __init__(self,*args,**kwargs):
        super(SingletonType,self).__init__(*args,**kwargs)

    def __call__(cls, *args, **kwargs): # 这里的cls,即Foo类
        print('cls',cls)
        obj = cls.__new__(cls,*args, **kwargs)
        cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
        return obj

class Foo(metaclass=SingletonType): # 指定创建Foo的type为SingletonType
    def __init__(self,name):
        self.name = name
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)

obj = Foo('xx')

 

相关知识

"""
1.类由type创建,创建类时候type的__init__方法自动执行,类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
2.对象由类创建,创建对象时候类的__init__方法自动执行,对象()执行类的 __call__ 方法
"""

例子:

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        pass

obj = Foo()
# 执行type的 __call__ 方法,调用 Foo类(是type的对象)的 __new__方法,用于创建对象,然后调用 Foo类(是type的对象)的 __init__方法,用于对对象初始化。

obj()    # 执行Foo的 __call__ 方法    

 

元类的运用

class SingletonType(type):
    def __init__(self,*args,**kwargs):
        super(SingletonType,self).__init__(*args,**kwargs)

    def __call__(cls, *args, **kwargs): # 这里的cls,即Foo类
        print('cls',cls)
        obj = cls.__new__(cls,*args, **kwargs)
        cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
        return obj

class Foo(metaclass=SingletonType): # 指定创建Foo的type为SingletonType
    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)

obj = Foo()

 

福寿无疆单例形式

import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)

 

 

落成单例方式

import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)

 

 

单例格局 单例形式(Singleton Pattern)
是一种常用的软件设计格局,该格局…