python3 singleton

在python 中 创单例子方法有那些了，带着好奇，今天来总结以下：

类在实例化时，首先是调用__new__方法，创建出一个实例，然后再去调用__init__ 方法对该实例进行初始化操作
第一种：

class Singleton(object):

    instance = None

    def __init__(self,*args, **kwargs):#每次都要初始化，调用多次
       pass

    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls, *args, **kwargs)
        return cls.instance

t1 = Singleton()
t2 = Singleton()
assert id(t1) == id(t2)
#在高并发的时候，如果都进入 if cls.instance is None: 行，单独实例就没法保证
或者：
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"_instance"):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

s1 = Singleton()
s2 = Singleton()

第三种

import threading
class Singleton(object):
    vars = {}
    single_lock = threading.Lock()
    def (cls, *args, **kwargs):
        if cls in cls.vars:
            return cls.vars[cls]
        cls.single_lock.acquire()
        try:
            if cls in cls.vars:
                return cls.vars[cls]
            cls.vars[cls] = super().__new__(cls, *args, **kwargs)
            return cls.vars[cls]
        finally:
            cls.single_lock.release()
t1 = Singleton()
t2 = Singleton()
assert id(t1) == id(t2)
# 利用threading lock 来实现，单在子类重载过此中，子类重新实现，不安全

第三种

#利用装饰起decorator 模式

def singleton(cls, *args, **kwargs):
    instances = {}
    def getInstance():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return getInstance

@singleton
class Singleton(object):
    pass
t1 = Singleton()
t2 = Singleton()

第四种：

class Singleton1(type):

    _inst = {}

    def __call__(self, *args, **kw):
        if self not in self._inst:
            self._inst[self] = super(Singleton1, self).__call__(*args, **kw)
        return self._inst[self]

class MyClass1(metaclass=Singleton1):
    def __init__(self):
        self.xx = 0

    def getval(self):
        return self.xx

    def setval(self, val):
        self.xx = val