# Python单例模式最佳实践

前言

今天在群里讨论时讨论到了单例模式，这应该是你们最熟悉的一种设计模式了。

简单而言，单例模式就是保证某个实例在项目的整个生命周期中只存在一个，在项目的任意位置使用，都是同一个实例。

单例模式虽然简单，但仍是有些门道的，而少有人知道这些门道。

边界状况

Python中实现单例模式的方法不少，我之前最常使用的应该是下面这种写法。

class Singleton(object):
    
    _instance = None
    def __new__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance
复制代码

这种写法有两个问题。

1.单例模式对应类实例化时没法传入参数，将上面的代码扩展成下面形式。

class Singleton(object):
    
    _instance = None
    def __new__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance

    def __init(self, x, y):
        self.x = x
        self.y = y

s = Singleton(1,2)
复制代码

此时会抛出TypeError: object.__new__() takes exactly one argument (the type to instantiate)错误

2.多个线程实例化Singleton类时，可能会出现建立多个实例的状况，由于颇有可能多个线程同时判断cls._instance is None，从而进入初始化实例的代码中。

基于同步锁实现单例

先考虑上述实现遇到的第二个问题。

既然多线程状况下会出现边界状况从而参数多个实例，那么使用同步锁解决多线程的冲突则可。

import threading

# 同步锁
def synchronous_lock(func):
    def wrapper(*args, **kwargs):
        with threading.Lock():
            return func(*args, **kwargs)
    return wrapper

class Singleton(object):
    instance = None

 @synchronous_lock
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = object.__new__(cls, *args, **kwargs)
        return cls.instance
复制代码

上述代码中经过threading.Lock()将单例化方法同步化，这样在面对多个线程时也不会出现建立多个实例的状况，能够简单试验一下。

def worker():
    s = Singleton()
    print(id(s))

def test():
    task = []
    for i in range(10):
        t = threading.Thread(target=worker)
        task.append(t)
    for i in task:
        i.start()
    for i in task:
        i.join()

test()
复制代码

运行后，打印的单例的id都是相同的。

更优的方法

加了同步锁以后，除了没法传入参数外，已经没有什么大问题了，可是否有更优的解决方法呢？单例模式是否有能够接受参数的实现方式？

阅读Python官方的wiki（wiki.python.org/moin/Python…

def singleton(cls):
    cls.__new_original__ = cls.__new__

 @functools.wraps(cls.__new__)
    def singleton_new(cls, *args, **kwargs):
        it = cls.__dict__.get('__it__')
        if it is not None:
            return it
        
        cls.__it__ = it = cls.__new_original__(cls, *args, **kwargs)
        it.__init_original__(*args, **kwargs)
        return it

    cls.__new__ = singleton_new
    cls.__init_original__ = cls.__init__
    cls.__init__ = object.__init__
    return cls
    
@singleton
class Foo(object):
    def __new__(cls, *args, **kwargs):
        cls.x = 10
        return object.__new__(cls)

    def __init__(self, x, y):
        assert self.x == 10
        self.x = x
        self.y = y

复制代码

上述代码中定义了singleton类装饰器，装饰器在预编译时就会执行，利用这个特性，singleton类装饰器中替换了类本来的__new__与__init__方法，使用singleton_new方法进行类的实例化，在singleton_new方法中，先判断类的属性中是否存在__it__属性，以此来判断是否要建立新的实例，若是要建立，则调用类本来的__new__方法完成实例化并调用本来的__init__方法将参数传递给当前类，从而完成单例模式的目的。

这种方法让单例类能够接受对应的参数但面对多线程同时实例化仍是可能会出现多个实例，此时加上线程同步锁则可。

def singleton(cls):
    cls.__new_original__ = cls.__new__
 @functools.wraps(cls.__new__)
    def singleton_new(cls, *args, **kwargs):
        # 同步锁
        with threading.Lock():
            it = cls.__dict__.get('__it__')
            if it is not None:
                return it
            
            cls.__it__ = it = cls.__new_original__(cls, *args, **kwargs)
            it.__init_original__(*args, **kwargs)
            return it

    cls.__new__ = singleton_new
    cls.__init_original__ = cls.__init__
    cls.__init__ = object.__init__
    return cls
复制代码

是否加同步锁的额外考虑

若是一个项目不须要使用线程相关机制，只是在单例化这里使用了线程锁，这其实不是必要的，它会拖慢项目的运行速度。

阅读CPython线程模块相关的源码，你会发现，Python一开始时并无初始化线程相关的环境，只有当你使用theading库相关功能时，才会调用PyEval_InitThreads方法初始化多线程相关的环境，代码片断以下（我省略了不少不相关代码）。

static PyObject * thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs) {
    PyObject *func, *args, *keyw = NULL;
    struct bootstate *boot;
    unsigned long ident;
    
    // 初始化多线程环境，解释器默认不初始化，只有用户使用时，才初始化。
    PyEval_InitThreads(); /* Start the interpreter's thread-awareness */
    // 建立线程
    ident = PyThread_start_new_thread(t_bootstrap, (void*) boot);
    
    // 返回线程id
    return PyLong_FromUnsignedLong(ident);
}
复制代码

为何会这样？

由于多线程环境会启动GIL锁相关的逻辑，这会影响Python程序运行速度。不少简单的Python程序并不须要使用多线程，此时不须要初始化线程相关的环境，Python程序在没有GIL锁的状况下会运行的更快。

若是你的项目中不会涉及多线程操做，那么就没有使用有同步锁来实现单例模式。​

结尾

互联网中有不少Python实现单例模式的文章，你只须要从多线程下是否能够保证单实例以及单例化时是否能够传入初始参数两点来判断相应的实现方法则可。

欢迎关注「懒编程」，一块儿探索技术的本质。