Python设计模式之单例模式

Posted 2020-09-26

单例模式

单例模式需要注意的地方在于

• 如何保证创建的实例是唯一的
• 如何保证多线程情况下的访问
• 清晰明了

目前有这么几种方法：

1. module
2. metaclass
3. __new__
4. decorator

module

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

1. 首先在一个py文件中定义这么一个单例类：

class Singleton(object):
    def __init__(self):
        self._val = 10
    @property
    def val(self):
        return self._val
    @val.setter
    def val(self, val):
        self._val = val
singleton = Singleton()

1. 然后再在其它的文件中import

from Singleton import singleton
assert singleton.val == 10
singleton.val = 20
assert singleton.val == 20

但是这个有个缺点，就是程序一开始的时候就进行了创建，造成不必要的浪费，最好是在使用的时候才进行创建，还有另外一个缺点在于，如果有人不遵守规定使用已经创建好的实例而是自己创建则无法实现单例。

metaclass

这正是元类可以做的事情－通过声明一个元类，我们告诉Python把类对象的创建路由到是我们提供的另一个类，从而达到拦截类的创建的目的。客户唯一需要的是，它们需要声明元类，每个这么做的都会自动获取到元类所提供的扩展。

class Singleton(type):
    def __init__(cls, what, bases, dict):
        super().__init__(what, bases, dict)
        cls._instance = None
    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__call__(*args, **kwargs)
        return cls._instance
class MyClass(metaclass=Singleton):
    pass
class1 = MyClass()
class2 = MyClass()
assert class1 == class2

__call__

如果在子类中如果没有重载__new__方法，那么子类则会顺着继承关系，找到父类中的__new__，但是如果子类已经重载了，而且没有显式的调用父类的方法，则相当于再次进行重载，就不会再去调用父类的__new__方法，需要注意！

class Singleton(object):
    _instance = None
    def __new__(cls, *more):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *more)
        return cls._instance
class MyClass(Singleton):
    pass
class1 = MyClass()
class2 = MyClass()
assert id(class1) == id(class2)

装饰器

在装饰器中，我们通过拦截它的__new__实现，判断它是否存在于该类的__dict__字典中，如果存在则返回，不存在则创建该类并且存放于__dict__中，并且进行相应的初始化。

import functools
def singleton(cls):
    cls.__new_original__ = cls.__new__
    @functools.wraps(cls.__new__)
    def singleton_new(cls, *args, **kw):
        it = cls.__dict__.get(‘__it__‘)
        if it is not None:
            return it
        cls.__it__ = it = cls.__new_original__(cls, *args, **kw)
        it.__init_original__(*args, **kw)
        return it
    cls.__new__ = singleton_new
    cls.__init_original__ = cls.__init__
    cls.__init__ = object.__init__
    return cls
@singleton
class myclass:
    pass
class1 = myclass()
class2 = myclass()
assert class1 == class2