[Python]单例模式

单例模式(Singleton Pattern)是一种常用的软件设计模式，它用来确保一个类只有一个实例，并提供一个全局访问点。

当你想要在整个系统中确保某个类只有一个实例的时候，单例模式就能派上用场了。比如，客户端通过一个AppConfig类来读写保存在配置文件中的信息，在程序运行期间，有多个地方需要读取，修改配置信息，如果每次读写都生成一个APPConfig类的实例，一来每次都从文件读取影响性能，二来程序在运行期间会有多个实例，浪费资源。所以我们希望在程序运行期间只有一个AppConfig类的实例。

Python实现单例模式有几种方法：

1. 使用模块
2. 使用__new__“构造器”
3. 使用装饰器
4. 使用元类

使用模块

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__“构造器”，装饰器，元类四种方法来实现单例模式，另外除了模块之外，其他三种方式都不是线程安全的，但可以通过“双重检查加锁”的方法来实现线程安全。