python 中单例模式的实现

单例模式的使用场景

很多初学者喜欢用全局变量，因为这比函数的参数传来传去更容易让人理解。确实在很多场景下用全局变量很方便。不过如果代码规模增大，并且有多个文件的时候，全局变量就会变得比较混乱。你可能不知道在哪个文件中定义了相同类型甚至重名的全局变量，也不知道这个变量在程序的某个地方被做了怎样的操作。
因此对于这种情况，有种更好的实现方式：单例（Singleton）
单例是一种设计模式，应用该模式的类只会生成一个实例。
单例模式保证了在程序的不同位置都可以且仅可以取到同一个对象实例：如果实例不存在，会创建一个实例；如果已存在就会返回这个实例。因为单例是一个类，所以你也可以为其提供相应的操作方法，以便于对这个实例进行管理。
举个例子来说，比如你开发一款游戏软件，游戏中需要有“场景管理器”这样一种东西，用来管理游戏场景的切换、资源载入、网络连接等等任务。这个管理器需要有多种方法和属性，在代码中很多地方会被调用，且被调用的必须是同一个管理器，否则既容易产生冲突，也会浪费资源。这种情况下，单例模式就是一个很好的实现方法。

使用函数装饰器来实现单例

def singleton(cls):
    _instance = {}

    def inner():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]

    return inner


@singleton
class Cls(object):
    def __init__(self):
        pass


def main():
    cls1 = Cls()
    cls2 = Cls()
    print(cls1 == cls2)
    print(cls1 is cls2)


if __name__ == "__main__":
    main()

使用不可变的类地址作为键，其实例作为值，每次创造实例时，首先查看该类是否存在实例，存在的话直接返回该实例即可，否则新建一个实例并存放在字典中。

使用类装饰器

class Singleton(object):
    def __init__(self, cls):
        self._cls = cls
        self._instance = {}

    def __call__(self):
        if self._cls not in self._instance:
            self._instance[self._cls] = self._cls()
        return self._instance[self._cls]


@Singleton
class Cls2(object):
    def __init__(self):
        pass


def main():
    cls1 = Cls2()
    cls2 = Cls2()
    print(id(cls1) == id(cls2))


if __name__ == "__main__":
    main()

以上的用法其实和下面这种类似:

class Cls3(object):
    pass

Cls3 = Singleton(Cls3)
cls3 = Cls3()
cls4 = Cls3()
print(id(cls3) == id(cls4))

这样改写后，可以发现实现原理和函数装饰器一致。

使用 new 关键字实现单例模式

元类(metaclass) 可以通过方法 metaclass 创造了类(class)，而类(class)通过方法 new 创造了实例(instance)。
在单例模式应用中，在创造类的过程中或者创造实例的过程中稍加控制达到最后产生的实例都是一个对象的目的。
参考以下文章：
• What are metaclasses in Python?
• python-new-magic-method-explained
• Why is init() always called after new()?

class Single(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):
        pass


single1 = Single()
single2 = Single()
print(id(single1) == id(single2))

在理解到 new 的应用后，理解单例就不难了，这里使用了 _instance = None
来存放实例，如果 instance 为 None，则新建实例，否则直接返回 instance 存放的实例。

使用 metaclass 实现单例模式

同样，我们在类的创建时进行干预，从而达到实现单例的目的。
在实现单例之前，需要了解使用 type 创造类的方法，代码如下：

# 使用 type 创建一个类 
def func(self):
    print("do sth")


Klass = type("Klass", (), {"func": func})

c = Klass()
c.func()

以上，我们使用 type 创造了一个类出来。这里的知识是 mataclass 实现单例的基础

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]


class Cls4(metaclass=Singleton):
    # 这里，我们将 metaclass 指向 Singleton 类，让 Singleton 中的 type 来创造新的 Cls4 实例。 
    pass


cls1 = Cls4()
cls2 = Cls4()
print(id(cls1) == id(cls2))

转载原文

https://zhuanlan.zhihu.com/p/37534850