python的单例模式
Posted 谷永辉
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python的单例模式相关的知识,希望对你有一定的参考价值。
单例模式(Singleton Pattern),是一种软件设计模式,是类只能实例化一个对象,
目的是便于外界的访问,节约系统资源,如果希望系统中 只有一个对象可以访问,就用单例模式,
显然单例模式的要点有三个;一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。
在 Python 中,我们可以用多种方法来实现单例模式:
- 使用模块
- 使用
__new__
- 使用装饰器(decorator)
- 使用元类(metaclass)
概念
简单说,单例模式(也叫单件模式)的作用就是保证在整个应用程序的生命周期中,任何一个时刻,单例类的实例都只存在一个(当然也可以不存在)
例子:
一台计算机上可以连好几个打印机,但是这个计算机上的打印程序只能有一个,这里就可以通过单例模式来避免两个打印作业同时输出到打印机中,即在整个的打印过程中我只有一个打印程序的实例。
代码
import threading
class Signleton(object):
def __init__(self):
print("__init__ method called")
def __new__(cls):
print("__new__ method called")
mutex=threading.Lock()
mutex.acquire() # 上锁,防止多线程下出问题
if not hasattr(cls, ‘instance‘):
cls.instance = super(LogSignleton, cls).__new__(cls)
mutex.release()
return cls.instance
if __name__ == ‘__main__‘:
obj = Signleton()
输出结果:
>>> ================================ RESTART ================================
>>>
__new__ method called
__init__ method called
>>>
说明
1.从输出结果来看,最先调用 __new__ 方法,然后调用__init__方法
2. __new__ 通常用于控制生成一个新实例的过程,它是类级别的方法。
3. __init__ 通常用于初始化一个新实例,控制这个初始化的过程,比如添加一些属性,做一些额外的操作,发生在类实例被创建完以后。它是实例级别的方法。
方法1;
__new__ 在__init__初始化前,就已经实例化对象,可以利用这个方法实现单例模式。
- print ‘----------------------方法1--------------------------‘
- #方法1,实现__new__方法
- #并在将一个类的实例绑定到类变量_instance上,
- #如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
- #如果cls._instance不为None,直接返回cls._instance
- class Singleton(object):
- def __new__(cls, *args, **kw):
- if not hasattr(cls, ‘_instance‘):
- orig = super(Singleton, cls)
- cls._instance = orig.__new__(cls, *args, **kw)
- return cls._instance
- class MyClass(Singleton):
- a = 1
- one = MyClass()
- two = MyClass()
- two.a = 3
- print one.a
- #3
- #one和two完全相同,可以用id(), ==, is检测
- print id(one)
- #29097904
- print id(two)
- #29097904
- print one == two
- #True
- print one is two
- #True
- print ‘----------------------方法2--------------------------‘
- #方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
- #同一个类的所有实例天然拥有相同的行为(方法),
- #只需要保证同一个类的所有实例具有相同的状态(属性)即可
- #所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
- #可参看:http://code.activestate.com/recipes/66531/
- class Borg(object):
- _state = {}
- def __new__(cls, *args, **kw):
- ob = super(Borg, cls).__new__(cls, *args, **kw)
- ob.__dict__ = cls._state
- return ob
- class MyClass2(Borg):
- a = 1
- one = MyClass2()
- two = MyClass2()
- #one和two是两个不同的对象,id, ==, is对比结果可看出
- two.a = 3
- print one.a
- #3
- print id(one)
- #28873680
- print id(two)
- #28873712
- print one == two
- #False
- print one is two
- #False
- #但是one和two具有相同的(同一个__dict__属性),见:
- print id(one.__dict__)
- #30104000
- print id(two.__dict__)
- #30104000
- print ‘----------------------方法3--------------------------‘
- #方法3:本质上是方法1的升级(或者说高级)版
- #使用__metaclass__(元类)的高级python用法
- class Singleton2(type):
- def __init__(cls, name, bases, dict):
- super(Singleton2, cls).__init__(name, bases, dict)
- cls._instance = None
- def __call__(cls, *args, **kw):
- if cls._instance is None:
- cls._instance = super(Singleton2, cls).__call__(*args, **kw)
- return cls._instance
- class MyClass3(object):
- __metaclass__ = Singleton2
- one = MyClass3()
- two = MyClass3()
- two.a = 3
- print one.a
- #3
- print id(one)
- #31495472
- print id(two)
- #31495472
- print one == two
- #True
- print one is two
- #True
- print ‘----------------------方法4--------------------------‘
- #方法4:也是方法1的升级(高级)版本,
- #使用装饰器(decorator),
- #这是一种更pythonic,更elegant的方法,
- #单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
- def singleton(cls, *args, **kw):
- instances = {}
- def _singleton():
- if cls not in instances:
- instances[cls] = cls(*args, **kw)
- return instances[cls]
- return _singleton
- @singleton
- class MyClass4(object):
- a = 1
- def __init__(self, x=0):
- self.x = x
- one = MyClass4()
- two = MyClass4()
- two.a = 3
- print one.a
- #3
- print id(one)
- #29660784
- print id(two)
- #29660784
- print one == two
- #True
- print one is two
- #True
- one.x = 1
- print one.x
- #1
- print two.x
==========================================================
-
单例模式
单例模式(Singleton Pattern)是一种常用的软件设计模式,该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中,某个类只能出现一个实例时,单例对象就能派上用场。
比如,某个服务器程序的配置信息存放在一个文件中,客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间,有很多地方都需要使用配置文件的内容,也就是说,很多地方都需要创建 AppConfig 对象的实例,这就导致系统中存在多个 AppConfig 的实例对象,而这样会严重浪费内存资源,尤其是在配置文件内容很多的情况下。事实上,类似 AppConfig 这样的类,我们希望在程序运行期间只存在一个实例对象。
在 Python 中,我们可以用多种方法来实现单例模式:
- 使用模块
- 使用
__new__
- 使用装饰器(decorator)
- 使用元类(metaclass)
使用模块
其实,Python 的模块就是天然的单例模式,因为模块在第一次导入时,会生成
.pyc
文件,当第二次导入时,就会直接加载.pyc
文件,而不会再次执行模块代码。因此,我们只需把相关的函数和数据定义在一个模块中,就可以获得一个单例对象了。如果我们真的想要一个单例类,可以考虑这样做:123456# mysingleton.pyclass My_Singleton(object):def foo(self):passmy_singleton = My_Singleton()将上面的代码保存在文件
mysingleton.py
中,然后这样使用:123from mysingleton import my_singletonmy_singleton.foo()使用
__new__
为了使类只能出现一个实例,我们可以使用
__new__
来控制实例的创建过程,代码如下:123456789class Singleton(object):_instance = Nonedef __new__(cls, *args, **kw):if not cls._instance:cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)return cls._instanceclass MyClass(Singleton):a = 1在上面的代码中,我们将类的实例和一个类变量
_instance
关联起来,如果cls._instance
为 None 则创建实例,否则直接返回cls._instance
。执行情况如下:
12345678>>> one = MyClass()>>> two = MyClass()>>> one == twoTrue>>> one is twoTrue>>> id(one), id(two)(4303862608, 4303862608)使用装饰器
我们知道,装饰器(decorator)可以动态地修改一个类或函数的功能。这里,我们也可以使用装饰器来装饰某个类,使其只能生成一个实例,代码如下:
1234567891011121314from functools import wrapsdef singleton(cls):instances = {}@wraps(cls)def getinstance(*args, **kw):if cls not in instances:instances[cls] = cls(*args, **kw)return instances[cls]return getinstance@singletonclass MyClass(object):a = 1在上面,我们定义了一个装饰器
singleton
,它返回了一个内部函数getinstance
,该函数会判断某个类是否在字典instances
中,如果不存在,则会将cls
作为 key,cls(*args, **kw)
作为 value 存到instances
中,否则,直接返回instances[cls]
。使用 metaclass
元类(metaclass)可以控制类的创建过程,它主要做三件事:
- 拦截类的创建
- 修改类的定义
- 返回修改后的类
使用元类实现单例模式的代码如下:
1234567891011121314class Singleton(type):_instances = {}def __call__(cls, *args, **kwargs):if cls not in cls._instances:cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)return cls._instances[cls]# Python2class MyClass(object):__metaclass__ = Singleton# Python3# class MyClass(metaclass=Singleton):# pass
-
以上是关于python的单例模式的主要内容,如果未能解决你的问题,请参考以下文章