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为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都是相同的。

更优的方法

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

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

上面代码中定义了单例类装饰器，装饰器会在预编译时执行。使用此功能，单例类装饰器替换了原来的 __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 程序不需要使用多线程。此时不需要初始化线程相关的环境。没有 GIL 锁，Python 程序会运行得更快。

如果你的项目不涉及多线程操作，那么就没有使用同步锁来实现单例模式。

结尾

网上有很多文章用Python实现单例模式。只需要从多线程下能不能保证单实例，单例时能不能传入初始参数来判断

相应的实现方法则可。