大奖网官方网站 > 下载中心 > 大奖网官方网站Python中的单例模式的几种实现方式的及优化,Python中的单例模式的几种实现方式的优缺点及优化

原标题:大奖网官方网站Python中的单例模式的几种实现方式的及优化,Python中的单例模式的几种实现方式的优缺点及优化

浏览次数:59 时间:2019-10-30

单例方式

单例格局(Singleton Pattern)是生机勃勃种常用的软件设计方式,该方式的要紧目标是保证某四个类独有一个实例存在。当您愿目的在于全路种类中,某些类只可以出现一个实例时,单例对象就会派上用场。

比如,有个别服务器程序的安插新闻寄放在一个文件中,顾客端通过四个 AppConfig 的类来读取配置文件的新闻。要是在程序运转时期,有为数不菲地点都亟待选用陈设文件的内容,约等于说,非常多地点都亟需创造AppConfig 对象的实例,那就导致系统中设有多少个 AppConfig 的实例对象,而如此会严重浪费内部存款和储蓄器能源,尤其是在配备文件内容非常多的情况下。事实上,相仿AppConfig 那样的类,大家希望在程序运营时期只存在二个实例对象。

在 Python 中,大家得以用三种主意来达成单例格局

 

Python中的单例格局的二种完结方式的得失及优化,python优瑕疵

贯彻单例格局的两种艺术

单例情势

单例方式(Singleton Pattern)是意气风发种常用的软件设计格局,该情势的基本点指标是确认保障某二个类独有叁个实例存在。当你希望在全种类统中,某些类只可以现身多少个实例时,单例对象就能够派上用场。

诸如,有些服务器程序的配置信息贮存在一个文书中,顾客端通过二个 AppConfig 的类来读取配置文件的音信。假设在程序运转时期,有过多地点都必要利用布署文件的剧情,约等于说,超多地方都急需创建AppConfig 对象的实例,那就导致系统中存在多个 AppConfig 的实例对象,而那般会严重浪费内部存款和储蓄器能源,特别是在安排文件内容超多的景况下。事实上,相仿AppConfig 这样的类,我们盼望在程序运维时期只设有二个实例对象。

在 Python 中,大家能够用二种主意来落到实处单例格局

 

1.运用模块

其实,Python 的模块正是先本性的单例形式,因为模块在第一遍导入时,会生成 .pyc 文件,当第贰回导入时,就能够平昔加载 .pyc 文件,而不会重新施行模块代码。由此,我们只需把有关的函数和数码定义在三个模块中,就可以获得叁个单例对象了。若是大家真的想要二个单例类,能够杜撰那样做:

mysingleton.py

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

将上边的代码保存在文件 mysingleton.py 中,要选择时,直接在此外文件中程导弹入此文件中的对象,这么些目的正是单例形式的指标

from a import singleton

 

落到实处单例方式的两种办法

2.采纳装饰器

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)

 

 

1.运用模块

其实,Python 的模块就是先性子的单例方式,因为模块在率先次导入时,会生成 .pyc 文件,当第一遍导入时,就能够向来加载 .pyc 文件,而不会再度试行模块代码。由此,大家只需把相关的函数和多少定义在贰个模块中,就能够收获三个单例对象了。若是大家实在想要一个单例类,能够杜撰那样做:

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>

主题素材现身了!遵照以上办法创建的单例,超小概支撑八线程

 

化解办法:加锁!未加锁部分现身实施,加锁部分串行实施,速度下降,不过保险了多少安全

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

诸如此比,叁个方可支撑多线程的单例格局就成功了

大奖网官方网站 1大奖网官方网站 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

如此,三个可以支撑八线程的单例形式就到位了

大奖网官方网站 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,]) 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>

 

选择这种措施的单例格局,现在实例化对象时,和日常实例化对象的点子相同 obj = Singleton() 

 

5.基于metaclass情势完成

4.基于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) 是大器晚成种常用的软件设计形式,该方式...

本文由大奖网官方网站发布于下载中心,转载请注明出处:大奖网官方网站Python中的单例模式的几种实现方式的及优化,Python中的单例模式的几种实现方式的优缺点及优化

关键词:

上一篇:没有了

下一篇:没有了