四种方式实现单例模式

基于__new__方法实现(推荐使用)

当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式

# 重写__new__方法，实现每一次实例化的时候，返回同一个instance对象
class Singleton:
    def __new__(cls, *args, **kwargs):      
        #判断类cls是否有_instance属性
        if not hasattr(cls, '_instance'):  #  _instance不能改成其他变量，改了单例模式就失效了
            #将一个类的实例绑定到类属性_instance上
            cls._instance = object.__new__(Singleton)
        return cls._instance  # 下一个实例化对象返回的是上一个的对象

    def __init__(self, name, age):
        # 第二个实例对象s2虽然返回的是第一个对象，但是还是会走init方法，把name和age修改了
        self.name = name
        self.age = age

s1 = Singleton('张三', 24)
s2 = Singleton('李四', 20)
print(s1, s2)  # 这两实例都一样
print(s1.name, s2.name)
print(id(s1))
print(id(s2))

注意：__new__方法无法避免触发__init__方法，初始的成员变量会进行覆盖。

模块单例

Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。

#foo1.py
class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()


#foo.py
from foo1 import singleton

装饰器

原理：装饰器用来控制类调用__call__方法。

def singleton(cls, *args, **kw):
    instance = {}
    def _singleton(args):
        if cls not in instance:
            instance[cls] = cls(*args, **kw)
        return instance[cls]
    return _singleton

@singleton
class A:
    pass

元类方法

'''
此方法是在__new__方法的更上层对实例化过程进行控制。

原理：执行元类的__new__方法和__init__方法用来实例化类对象，__call__ 方法用来对实例化的对象的实例即类的对象进行控制。__call__方法会调用实例类的 __new__方法，用于创建对象。返回对象给__call__方法，然后调用类对象的 __init__方法，用于对对象初始化。
'''

class Singleton1(type):
    def __init__(self, *args, **kwargs):
        self.__instance = None
        super(Singleton1,self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            self.__instance = super(Singleton1,self).__call__(*args, **kwargs)
        return self.__instance

class Singleton2(type):
    _inst = {}
    def __call__(cls, *args, **kwargs):
        print(cls)
        if cls not in cls._inst:
            cls._inst[cls] = super(Singleton2, cls).__call__(*args)
        return cls._inst[cls]

class C(metaclass=Singleton1):
    pass

除了模块单例外，其他几种模式的本质都是通过设置中间变量，来判断类是否已经被实例。区别就是中间变量的位置不同，或设置在元类中，或封装在函数中，或设置在类中作为静态变量。

注意：中间变量的访问和更改存在线程安全的问题：在开启多线程模式的时候需要加锁处理。