# 基本原理：
- 第一類(lèi)通過(guò)模塊導(dǎo)入的方式，借用了模塊導(dǎo)入時(shí)的底層原理實(shí)現(xiàn)。
- 當(dāng)一個(gè)模塊（py文件）被導(dǎo)入時(shí)，首先會(huì)執(zhí)行這個(gè)模塊的代碼，然后將這個(gè)模塊的名稱(chēng)空間加載到內(nèi)存。
- 當(dāng)這個(gè)模塊第二次再被導(dǎo)入時(shí)，不會(huì)再執(zhí)行該文件，而是直接在內(nèi)存中找。
- 于是，如果第一次導(dǎo)入模塊，執(zhí)行文件源代碼時(shí)實(shí)例化了一個(gè)類(lèi)，那再次導(dǎo)入的時(shí)候，就不會(huì)再實(shí)例化。

- 第二類(lèi)主要是基于類(lèi)和元類(lèi)實(shí)現(xiàn)，在'對(duì)象'的魔法方法中判斷是否已經(jīng)實(shí)例化過(guò)一個(gè)對(duì)象
- 這類(lèi)方式，根據(jù)實(shí)現(xiàn)的手法不同，又分為不同的方法，如：
- 通過(guò)類(lèi)的綁定方法；通過(guò)元類(lèi)；通過(guò)類(lèi)下的__new__；通過(guò)裝飾器（函數(shù)裝飾器，類(lèi)裝飾器）實(shí)現(xiàn)等。

# 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)

# 原理：模塊第二次導(dǎo)入從內(nèi)存找的機(jī)制

class Student:
  _instance = None	# 記錄實(shí)例化對(duì)象

  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__)

# 原理：類(lèi)的綁定方法是第二種實(shí)例化對(duì)象的方式，
# 第一次實(shí)例化的對(duì)象保存成類(lèi)的數(shù)據(jù)屬性 _instance，
# 第二次再實(shí)例化時(shí)，在get_singleton中判斷已經(jīng)有了實(shí)例對(duì)象，直接返回類(lèi)的數(shù)據(jù)屬性 _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	        # 有實(shí)例則直接返回
    # else:
    #   cls._instance = super().__new__(cls)	# 沒(méi)有實(shí)例則new一個(gè)并保存
    #   return cls._instance	        # 這個(gè)返回是給是給init，再實(shí)例化一次，也沒(méi)有關(guān)系

    if not cls._instance:	            # 這是簡(jiǎn)化的寫(xiě)法，上面注釋的寫(xiě)法更容易提現(xiàn)判斷思路
      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類(lèi)似，將判斷的實(shí)現(xiàn)方式，從類(lèi)的綁定方法中轉(zhuǎn)移到類(lèi)的__new__中
# 歸根結(jié)底都是 判斷類(lèi)有沒(méi)有實(shí)例，有則直接返回，無(wú)則實(shí)例化并保存到_instance中。

class Mymeta(type):

  def __init__(cls, name, bases, dic):
    super().__init__(name, bases, dic)
    cls._instance = None		         # 將記錄類(lèi)的實(shí)例對(duì)象的數(shù)據(jù)屬性放在元類(lèi)中自動(dòng)定義了

  def __call__(cls, *args, **kwargs):	         # 此call會(huì)在類(lèi)被調(diào)用（即實(shí)例化時(shí)觸發(fā)）
    if cls._instance:				 # 判斷類(lèi)有沒(méi)有實(shí)例化對(duì)象
      return cls._instance
    else:						 # 沒(méi)有實(shí)例化對(duì)象時(shí)，控制類(lèi)造空對(duì)象并初始化
      obj = cls.__new__(cls, *args, **kwargs)
      obj.__init__(*args, **kwargs)
      cls._instance = obj			     # 保存對(duì)象，下一次再實(shí)例化可以直接返回而不用再造對(duì)象
      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__)

# 原理：類(lèi)定義時(shí)會(huì)調(diào)用元類(lèi)下的__init__，類(lèi)調(diào)用(實(shí)例化對(duì)象)時(shí)會(huì)觸發(fā)元類(lèi)下的__call__方法
# 類(lèi)定義時(shí)，給類(lèi)新增一個(gè)空的數(shù)據(jù)屬性，
# 第一次實(shí)例化時(shí)，實(shí)例化之后就將這個(gè)對(duì)象賦值給類(lèi)的數(shù)據(jù)屬性；第二次再實(shí)例化時(shí)，直接返回類(lèi)的這個(gè)數(shù)據(jù)屬性
# 和方式3的不同之處1：類(lèi)的這個(gè)數(shù)據(jù)屬性是放在元類(lèi)中自動(dòng)定義的，而不是在類(lèi)中顯示的定義的。
# 和方式3的不同之處2：類(lèi)調(diào)用時(shí)觸發(fā)元類(lèi)__call__方法判斷是否有實(shí)例化對(duì)象，而不是在類(lèi)的綁定方法中判斷

def singleton(cls):
  _instance_dict = {}		         # 采用字典，可以裝飾多個(gè)類(lèi)，控制多個(gè)類(lèi)實(shí)現(xiàn)單例模式
 
  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的這部分代碼搬到了函數(shù)裝飾器中
  #   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		               # 這個(gè)語(yǔ)法糖相當(dāng)于Student = SingleTon(Student),即Student是SingleTon的實(shí)例對(duì)象
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__)

# 原理：在函數(shù)裝飾器的思路上，將裝飾器封裝成類(lèi)。
# 程序執(zhí)行到與語(yǔ)法糖時(shí)，會(huì)實(shí)例化一個(gè)Student對(duì)象，這個(gè)對(duì)象是SingleTon的對(duì)象。
# 后面使用的Student本質(zhì)上使用的是SingleTon的對(duì)象。
# 所以使用Student('jack', 18)來(lái)實(shí)例化對(duì)象，其實(shí)是在調(diào)用SingleTon的對(duì)象，會(huì)觸發(fā)其__call__的執(zhí)行
# 所以就在__call__中，判斷Student類(lèi)有沒(méi)有實(shí)例對(duì)象了。

import threading


class Student:

  _instance = None				# 保存單例對(duì)象
  _lock = threading.RLock()		    # 鎖

  def __new__(cls, *args, **kwargs):
    
    if cls._instance:			# 如果已經(jīng)有單例了就不再去搶鎖，避免IO等待
      return cls._instance
    
    with cls._lock:				# 使用with語(yǔ)法，方便搶鎖釋放鎖
      if not cls._instance:	
        cls._instance = super().__new__(cls, *args, **kwargs)
      return cls._instance