威尼斯人线上娱乐

Python中的单例格局的两种完毕情势的利害及优化,Python中的单例形式的二种完结方式的及优化

7 4月 , 2019  

单例格局

单例形式(Singleton
Pattern)
是一种常用的软件设计形式,该形式的显要指标是确认保证某三个类惟有3个实例存在。当您愿意在全数类别中,有个别类只可以出现1个实例时,单例对象就能派上用场。

譬如说,有个别服务器程序的布置新闻寄存在3个文件中,客户端通过三个 AppConfig
的类来读取配置文件的音信。假如在程序运营时期,有许多地点都亟待运用陈设文件的内容,也便是说,很多地方都需求创立AppConfig 对象的实例,这就导致系统中存在三个 AppConfig
的实例对象,而那般会严重浪费内部存储器财富,尤其是在安排文件内容很多的情景下。事实上,类似
AppConfig 那样的类,大家愿意在程序运营时期只存在叁个实例对象。

在 Python 中,大家得以用二种措施来兑现单例模式

 

Python中的单例形式的两种达成情势的优缺点及优化,python优缺点

单例格局

单例情势(Singleton
Pattern)
是壹种常用的软件设计格局,该方式的重大指标是确定保证某三个类唯有三个实例存在。当您愿目的在于任何体系中,有个别类只好出现一个实例时,单例对象就能派上用场。

Python中的单例格局的两种完毕情势的利害及优化,Python中的单例形式的二种完结方式的及优化。诸如,有个别服务器程序的配置新闻寄存在3个文书中,客户端通过3个 AppConfig
的类来读取配置文件的消息。固然在程序运营时期,有好多地点都急需使用布置文件的剧情,也正是说,很多地方都亟待成立AppConfig 对象的实例,这就导致系统中设有多少个 AppConfig
的实例对象,而这么会严重浪费内部存款和储蓄器财富,越发是在配备文件内容很多的意况下。事实上,类似
AppConfig 那样的类,大家希望在程序运营时期只存在三个实例对象。

在 Python 中,我们得以用各种格局来促成单例格局

 

依据Python中单例方式的二种完结格局及优化详解,python详解

单例形式

单例格局(Singleton
Pattern)是壹种常用的软件设计方式,该格局的主要性目标是保障某2个类唯有三个实例存在。当您期望在整整种类中,有个别类只好出现贰个实例时,单例对象就能派上用场。

比如,有些服务器程序的布署新闻寄存在三个文本中,客户端通过1个 AppConfig
的类来读取配置文件的音讯。假如在程序运营时期,有过多地方都亟需选拔布置文件的始末,约等于说,很多地点都急需创立AppConfig 对象的实例,那就导致系统中留存三个 AppConfig
的实例对象,而那样会严重浪费内部存储器财富,特别是在配置文件内容很多的气象下。事实上,类似
AppConfig 那样的类,大家愿意在程序运维期间只设有2个实例对象。

在 Python 中,我们得以用七种艺术来促成单例形式

兑现单例情势的三种情势

一.利用模块

实质上,Python 的模块正是先性子的单例情势,因为模块在第二次导入时,会扭转
.pyc 文件,当第二回导入时,就会直接加载 .pyc
文件,而不会另行实施模块代码。因而,大家只需把相关的函数和多少定义在3个模块中,就足以博得三个单例对象了。假诺我们实在想要三个单例类,能够设想那样做:

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

将方面包车型大巴代码保存在文书 mysingleton.py
中,要利用时,直接在此外文件中程导弹入此文件中的对象,那几个指标便是单例方式的对象

from a import 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

1般境况,大家认为这么就做到了单例格局,可是这么当使用十二线程时会存在难点

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方法中有1些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

诸如此类,三个方可支撑多线程的单例方式就做到了

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() ,那种艺术赢得的不是单例

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()

肆.基于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):
  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)

上述那篇基于Python中单例形式的两种完毕方式及优化详解就是小编分享给大家的全体内容了,希望能给我们3个参考,也期望大家多多帮忙帮客之家。

单例格局 单例情势(Singleton
Pattern)是一种常用的软件设计情势,该情势的主要…

落实单例情势的三种方法

单例形式

单例方式(Singleton
Pattern)
是壹种常用的软件设计格局,该格局的根本指标是承接保险某三个类唯有2个实例存在。当你希望在整个系统中,有些类只好出现一个实例时,单例对象就能派上用场。

例如,有个别服务器程序的布置新闻寄存在三个文书中,客户端通过2个 AppConfig
的类来读取配置文件的消息。如若在程序运维时期,有诸多地点都必要动用布置文件的情节,也等于说,很多地方都亟需成立AppConfig 对象的实例,那就导致系统中存在七个 AppConfig
的实例对象,而那般会严重浪费内部存款和储蓄器能源,特别是在安插文件内容很多的景象下。事实上,类似
AppConfig 那样的类,我们愿意在程序运维时期只存在1个实例对象。

在 Python 中,大家得以用二种措施来促成单例形式

 

兑现单例方式的两种艺术

1.施用模块

其实,Python
的模块就是自发的单例形式
,因为模块在第三回导入时,会生成 .pyc 文件,当第2遍导入时,就会一向加载 .pyc 文件,而不会再一次实施模块代码。因而,大家只需把相关的函数和数目定义在一个模块中,就足以获得贰个单例对象了。固然我们真正想要1个单例类,可以设想这么做:

mysingleton.py

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

将上边的代码保存在文书 mysingleton.py 中,要动用时,直接在任何文件中程导弹入此文件中的对象,那些指标便是单例形式的对象

from a import singleton

 

落实单例形式的二种方法

壹.施用模块

其实,Python
的模块就是自发的单例格局
,因为模块在第叁次导入时,会生成 .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 文件,当第3次导入时,就会一直加载 .pyc 文件,而不会另行实施模块代码。因而,大家只需把相关的函数和多少定义在1个模块中,就足以获取叁个单例对象了。假诺大家实在想要一个单例类,能够设想这么做:

mysingleton.py

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

将地方的代码保存在文书 mysingleton.py 中,要选取时,直接在别的文件中程导弹入此文件中的对象,这些指标便是单例形式的目的

from a import 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

相似景况,我们以为这么就完了了单例情势,不过如此当使用十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

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

诸如此类,二个得以支撑二十多线程的单例情势就完了了

威尼斯人线上娱乐 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()
,那种方式获取的不是单例

 

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

如此,2个能够帮助102线程的单例格局就到位了

威尼斯人线上娱乐 3威尼斯人线上娱乐 4

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>

标题出现了!根据以上办法开创的单例,无法支撑102线程

 

化解办法:加锁!未加锁部分出现执行,加锁部分串行执行,速度下滑,然而保障了数据安全

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)后,上面实例化对象时,此时早正是单例情势了,但大家如故加了锁,那样不太好,再进行1些优化,把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

那样,3个能够支撑八线程的单例情势就完了了

威尼斯人线上娱乐 5import
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()
,那种方法取得的不是单例

 

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)  
        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() 

 

4.基于__new__情势达成(推荐使用,方便)

通过上面例子,我们得以知道,当大家兑现单例时,为了确定保证线程安全须要在里面参加锁

我们领略,当大家实例化1个指标时,是先实施了类的__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() 

 

四.基于metaclass形式完毕

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,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)

 

 

贯彻单例格局

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)
是1种常用的软件设计方式,该格局…


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图