Python实现单例模式

单例模式 就是一个类的对象只能存在一个。单例模式是一种常见的软件设计模式，目的主要是节约系统内资源。

第一种：使用__new__，将一个类的实例绑定到类变量_insatance,

class Singleton(object):
    def __new__(cls,*args,**kw):
        if not hasattr(cls,'_instance'):
            cls._instance = super(Singleton,cls).__new__(cls,*args,**kw)
        return cls._instance



class MyClass(Singleton):
    a = 1


one = MyClass()
two = MyClass()


two.a = 2
print(one.a,two.a)#2,2

第二种：使用装饰器 decorator

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


@singleton
class MyClass(object):
    a = 1


one = MyClass()
two = MyClass()

two.a = 2
print(one.a,two.a)

第三种：使用_metaclass_元类来实现

当你编写一个类的时候，某种机制会使用类名字，基类元组，类字典来创建一个类对象。新型类中这种机制默认为type，而且这种机制是可编程的，称为元类__metaclass__ 。

class singleton(type):
    def __init__(self,name,bases,class_dict):
        super(singleton,self).__init__(name,bases,class_dict)
        self._instance = None
    def __call__(self,*args,**kw):
        if self._instance is None:
            self._instance = super(singleton,self).__call__(*args,**kw)
        return self._instance
    

class MyClass(object):
    __metaclass__ = singleton
    a = 1


one = MyClass()
two = MyClass()

two.a = 2
print(one.a,two.a)
print(id(one),id(two))

第四种 import方法 作为python的模块是天然的单例模式

class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()

#use
from mysingleton import my_singleton
my_singleton.foo()

第五种：共享属性，将所有实例的__dict__指向同一个字典，这样实例就会共享相同的属性和方法，但是id是不一样的。。要保证类实例能共享属性，但不和子类共享，注意使用cls._shared_state,而不是Borg._shared_state。

class Brog(object):
    _state = {}
    def __new__(cls,*args,**kw):
        ob = super(Brog,cls).__new__(cls,*args,**kw)
        ob.__dict__ = cls._state
        return ob


class MyClass(Brog):
    a = 1

one = MyClass()
two = MyClass()

two.a = 2

print(one.a,two.a)
print(id(one),id(two))
#2 2
#1963779029480 1963779029536