单例模式(Singleton Pattern)是一种常用的软件设计模式，它用来确保一个类只有一个实例，并提供一个全局访问点。
当你想要在整个系统中确保某个类只有一个实例的时候，单例模式就能派上用场了。比如，客户端通过一个AppConfig类来读写保存在配置文件中的信息，在程序运行期间，有多个地方需要读取，修改配置信息，如果每次读写都生成一个APPConfig类的实例，一来每次都从文件读取影响性能，二来程序在运行期间会有多个实例，浪费资源。所以我们希望在程序运行期间只有一个AppConfig类的实例。
Python实现单例模式有几种方法：
- 使用模块
- 使用__new__“构造器”
- 使用装饰器
- 使用元类
使用模块
Python的模块可以被多次import，但是只有在第一次import的时候才会load，load才会执行模块中的顶层代码，所以可以在一个模块中生成类实例，并在其他模块中import实例对象。例如：
class MySingleton(object):
def foo(self):
pass
singleton = MySingleton()
将上面的代码保存在my_singleton.py文件中，在需要访问MySingleton实例的模块中import
from my_singleton import singleton
singleton.foo()
这种方法的优点就是实现简单，但是因为是基于Python的import，load规则来实现的，所以也必然会被这个规则所影响，Python中有个reload()方法用来重新加载模块，调用之后会从新生成新的实例，从而导致老的实例数据丢失。
所以使用模块来实现单例模式，必须要注意不能reload模块
使用__new__“构造器”
__new__是一个特殊的“构造器”，它在__init__之前执行，它的职责就是为类创建一个实例对象，之后它创建的实例会传给__init__，所以可以通过它来实现单例模式。
class Singleton(object):
_instance = None
def __new__(cls, *args, **kwargs):
if not isinstance(cls._instance, cls):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
class MySingleton(Singleton):
pass
ms1 = MySingleton()
ms2 = MySingleton()
print id(ms1), id(ms2)
执行之后输出
222976992 222976992
两个实例的id相同
使用装饰器
可以用装饰器来装饰一个类，代码如下：
from functools import wraps
def singleton(cls):
_instance = {}
@wraps(cls)
def get_instance(*args, **kwargs):
if cls not in _instance:
_instance[cls] = cls(*args, **kwargs)
return _instance[cls]
return get_instance
@singleton
class MySingleton(object):
pass
print MySingleton, MySingleton.__name__
ms1 = MySingleton()
ms2 = MySingleton()
print id(ms1), id(ms2)
执行后输出
<function MySingleton at 0x000000000D3BC668> MySingleton
220845728 220845728
可以看到被装饰器装饰之后的类变成了一个方法，不再是个类了。可以通过修改装饰器来解决这个问题，修改后的装饰器代码如下：
def singleton2(cls):
class class_w(cls):
_instance = None
def __new__(cls, *args, **kwargs):
if class_w._instance is None:
class_w._instance = super(class_w, cls).__new__(cls, *args, **kwargs)
class_w._instance._sealed = False
return class_w._instance
def __init__(self, *args, **kwargs):
if self._sealed:
return
super(class_w, self).__init__(*args, **kwargs)
self._sealed = True
class_w.__name__ = cls.__name__
return class_w
执行之后输出
<class '__main__.MySingleton'> MySingleton
223306584 223306584
使用元类
因为本人还未掌握元类相关的知识点，所以只能给出一个摘至网上的例子，代码如下：
深入学习了下元类，相关资料见我的《[Python] 元类(Metaclasses )探索》一文。
针对下面的代码实现，我来解释一下，元类Singleton的__call__方法会在由它创建的类MySingleton创建实例的时候调用；__call__方法被调用之后，首先检查Singleton的类属性_instances这个字典里是否已经有了MySingleton这个类，如果没有则创建一个MySingleton类的实例保存到_instances中，最后返回_instances中保存的MySingleton的实例。
因为程序进程中只有一个Singleton元类对象，它的类属性_instances也是唯一的，所以通过Singleton元类创建的类，不论初始化多少次获取的实例都是同一个。
class 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]
#Python2
class MySingleton(object):
__metaclass__ = Singleton
#Python3
#class MySingleton(metaclass=Singleton):
# pass
s1 = MySingleton() # 调用Singleton元类的\_\_call\_\_方法
s2 = MySingleton()
print id(s1), id(s2)
执行之后输出
223306920 223306920
其他网上搜到的方法
在网上还存在着这样一种“实现”单例模式的方法
class Singleton(object):
_state = {}
def __new__(cls, *args, **kwargs):
instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
instance.__dict__ = cls._state
return instance
class MySingleton(Singleton):
pass
s1 = MySingleton()
s2 = MySingleton()
s1.a = 2
s2.a = 3
print 'instance id:', id(s1), id(s2)
print 'instance dict id:', id(s1.__dict__), id(s2.__dict__)
print 'instance.a:', s1.a, s2.a
执行之后输出
instance id: 220846064 223307032
instance dict id: 222032488 222032488
instance.a: 3 3
可以看到，两个实例对象的id不一样，但是实例的__dict__相同，而我们知道__dict__是用来存储实例对象的属性的，两个实例的__dict__相同，也就是两个实例的属性相同，间接达到了单例模式的其中一个效果。但是它不是单例模式，来回顾下单例模式的定义，确保一个类只有一个实例，并提供一个全局访问点，采用这种方式还是会生成多个实例，所以它不是单例模式。
线程安全的单例模式
上述的四种实现单例模式的方法除了第一种“使用模块”之外，全都不是线程安全的。模块因为是解释器load的，而解释器的GIL保证的线程安全，所以它是线程安全的。
剩下的三种方式，实现线程的安全的思路类似，我就通过装饰器方法来说明下。
import time
import threading
from multiprocessing.dummy import Pool as ThreadPool
def singleton_not_thread_safe(cls):
_instances = {}
def _instance(*args, **kwargs):
if cls not in _instances:
_instances[cls] = cls(*args, **kwargs)
return _instances[cls]
return _instance
def singleton_thread_safe(cls):
_instances = {}
_lock = threading.Lock()
def _instance(*args, **kwargs):
if cls not in _instances:
with _lock:
if cls not in _instances:
_instances[cls] = cls(*args, **kwargs)
return _instances[cls]
return _instance
@singleton_not_thread_safe
class NotThreadSafeSingleton(object):
def __init__(self):
time.sleep(1) # 模拟耗时I/O操作
@singleton_thread_safe
class ThreadSafeSingleton(object):
def __init__(self):
time.sleep(1)
def run(cls):
result_set = set()
result_set_access_lock = threading.Lock()
def worker(cls, result_set, result_set_access_lock):
instance= cls()
with result_set_access_lock:
result_set.add(instance)
thread_pool = ThreadPool(10)
for i in range(10):
thread_pool.apply_async(worker, (cls,result_set, result_set_access_lock))
thread_pool.close()
thread_pool.join()
print result_set
print len(result_set)
print '-' * 20, 'Not Thread Safe', '-' * 20
run(NotThreadSafeSingleton)
print '-' * 20, 'Thread Safe', '-' * 20
run(ThreadSafeSingleton)
输出
-------------------- Not Thread Safe --------------------
set([<__main__.NotThreadSafeSingleton object at 0x000000000D855C18>, <__main__.NotThreadSafeSingleton object at 0x000000000D855E48>, <__main__.NotThreadSafeSingleton object at 0x000000000D855860>, <__main__.NotThreadSafeSingleton object at 0x000000000D8ABCC0>, <__main__.NotThreadSafeSingleton object at 0x000000000D855CC0>, <__main__.NotThreadSafeSingleton object at 0x000000000D855320>, <__main__.NotThreadSafeSingleton object at 0x000000000D855D30>, <__main__.NotThreadSafeSingleton object at 0x000000000D855358>, <__main__.NotThreadSafeSingleton object at 0x000000000D855780>, <__main__.NotThreadSafeSingleton object at 0x000000000D8AB3C8>])
10
-------------------- Thread Safe --------------------
set([<__main__.ThreadSafeSingleton object at 0x000000000D8AB6A0>])
1
可以看到非线程安全的代码，会生成10个实例。
线程安全的核心代码：
def singleton_thread_safe(cls):
_instances = {}
_lock = threading.Lock()
def _instance(*args, **kwargs):
if cls not in _instances:
with _lock:
if cls not in _instances:
_instances[cls] = cls(*args, **kwargs)
return _instances[cls]
return _instance
可以看到在闭包里采用了“双重检查加锁”方法来实现线程安全
总结
好了，关于Python语言的单例模式我们就讲到这里，现在来回顾下，可以通过模块，__new__“构造器”，装饰器，元类四种方法来实现单例模式，另外除了模块之外，其他三种方式都不是线程安全的，但可以通过“双重检查加锁”的方法来实现线程安全。
网友评论