python 6种方法实现单例模式

 # 基本原理： - 第一类通过模块导入的方式，借用了模块导入时的底层原理实现。 - 当一个模块（py文件）被导入时，首先会执行这个模块的代码，然后将这个模块的名称空间加载到内存。 - 当这个模块第二次再被导入时，不会再执行该文件，而是直接在内存中找。 - 于是，如果第一次导入模块，执行文件源代码时实例化了一个类，那再次导入的时候，就不会再实例化。 - 第二类主要是基于类和元类实现，在'对象'的魔法方法中判断是否已经实例化过一个对象 - 这类方式，根据实现的手法不同，又分为不同的方法，如： - 通过类的绑定方法；通过元类；通过类下的__new__；通过装饰器（函数装饰器，类装饰器）实现等。

 # cls_singleton.py class Foo(object): pass instance = Foo() # test.py import cls_singleton obj1 = cls_singleton.instance obj2 = cls_singleton.instance print(obj1 is obj2) # 原理：模块第二次导入从内存找的机制

 class Student: _instance = None	# 记录实例化对象 def __init__(self, name, age): self.name = name self.age = age @classmethod def get_singleton(cls, *args, **kwargs): if not cls._instance: cls._instance = cls(*args, **kwargs) return cls._instance stu1 = Student.get_singleton('jack', 18) stu2 = Student.get_singleton('jack', 18) print(stu1 is stu2) print(stu1.__dict__, stu2.__dict__) # 原理：类的绑定方法是第二种实例化对象的方式， # 第一次实例化的对象保存成类的数据属性 _instance， # 第二次再实例化时，在get_singleton中判断已经有了实例对象，直接返回类的数据属性 _instance

 class Student: _instance = None def __init__(self, name, age): self.name = name self.age = age def __new__(cls, *args, **kwargs): # if cls._instance: #   return cls._instance	        # 有实例则直接返回 # else: #   cls._instance = super().__new__(cls)	# 没有实例则new一个并保存 #   return cls._instance	        # 这个返回是给是给init，再实例化一次，也没有关系 if not cls._instance:	            # 这是简化的写法，上面注释的写法更容易提现判断思路 cls._instance = super().__new__(cls) return cls._instance stu1 = Student('jack', 18) stu2 = Student('jack', 18) print(stu1 is stu2) print(stu1.__dict__, stu2.__dict__) # 原理：和方法2类似，将判断的实现方式，从类的绑定方法中转移到类的__new__中 # 归根结底都是 判断类有没有实例，有则直接返回，无则实例化并保存到_instance中。

 class Mymeta(type): def __init__(cls, name, bases, dic): super().__init__(name, bases, dic) cls._instance = None		         # 将记录类的实例对象的数据属性放在元类中自动定义了 def __call__(cls, *args, **kwargs):	         # 此call会在类被调用（即实例化时触发） if cls._instance:				 # 判断类有没有实例化对象 return cls._instance else:						 # 没有实例化对象时，控制类造空对象并初始化 obj = cls.__new__(cls, *args, **kwargs) obj.__init__(*args, **kwargs) cls._instance = obj			     # 保存对象，下一次再实例化可以直接返回而不用再造对象 return obj class Student(metaclass=Mymeta): def __init__(self, name, age): self.name = name self.age = age stu1 = Student('jack', 18) stu2 = Student('jack', 18) print(stu1 is stu2) print(stu1.__dict__, stu2.__dict__) # 原理：类定义时会调用元类下的__init__，类调用(实例化对象)时会触发元类下的__call__方法 # 类定义时，给类新增一个空的数据属性， # 第一次实例化时，实例化之后就将这个对象赋值给类的数据属性；第二次再实例化时，直接返回类的这个数据属性 # 和方式3的不同之处1：类的这个数据属性是放在元类中自动定义的，而不是在类中显示的定义的。 # 和方式3的不同之处2：类调用时触发元类__call__<strong style="color:transparent">来源gaodaima#com搞(代@码网</strong>方法判断是否有实例化对象，而不是在类的绑定方法中判断

 def singleton(cls): _instance_dict = {}		         # 采用字典，可以装饰多个类，控制多个类实现单例模式 def inner(*args, **kwargs): if cls not in _instance_dict: _instance_dict[cls] = cls(*args, **kwargs) return _instance_dict.get(cls) return inner @singleton class Student: def __init__(self, name, age): self.name = name self.age = age # def __new__(cls, *args, **kwargs):	 # 将方法3的这部分代码搬到了函数装饰器中 #   if not cls._instance: #     cls._instance = super().__new__(cls) #   return cls._instan stu1 = Student('jack', 18) stu2 = Student('jack', 18) print(stu1 is stu2) print(stu1.__dict__, stu2.__dict__)

 class SingleTon: _instance_dict = {} def __init__(self, cls_name): self.cls_name = cls_name def __call__(self, *args, **kwargs): if self.cls_name not in SingleTon._instance_dict: SingleTon._instance_dict[self.cls_name] = self.cls_name(*args, **kwargs) return SingleTon._instance_dict.get(self.cls_name) @SingleTon		               # 这个语法糖相当于Student = SingleTon(Student),即Student是SingleTon的实例对象 class Student: def __init__(self, name, age): self.name = name self.age = age stu1 = Student('jack', 18) stu2 = Student('jack', 18) print(stu1 is stu2) print(stu1.__dict__, stu2.__dict__) # 原理：在函数装饰器的思路上，将装饰器封装成类。 # 程序执行到与语法糖时，会实例化一个Student对象，这个对象是SingleTon的对象。 # 后面使用的Student本质上使用的是SingleTon的对象。 # 所以使用Student('jack', 18)来实例化对象，其实是在调用SingleTon的对象，会触发其__call__的执行 # 所以就在__call__中，判断Student类有没有实例对象了。

 import threading class Student: _instance = None				# 保存单例对象 _lock = threading.RLock()		    # 锁 def __new__(cls, *args, **kwargs): if cls._instance:			# 如果已经有单例了就不再去抢锁，避免IO等待 return cls._instance with cls._lock:				# 使用with语法，方便抢锁释放锁 if not cls._instance: cls._instance = super().__new__(cls, *args, **kwargs) return cls._instance