Python实现单例模式8种方法的优缺点比较

迷南。 2022-12-12 15:09 265阅读 0赞

转自 https://blog.csdn.net/u012324798/article/details/104056562

## 结论先行 ##

本文在比较了Python实现单例模式8种方法的优缺点之后，认为在Python中使用元类实现单例模式效果最好，推荐使用元类实现单例。

## 为什么要使用单例模式？ ##

通常情况下，一个类可以多次实例化，每个实例对象是相互独立的，即类在同一时刻可以有多种实例状态。

如果我们希望：

*  某个类在在同一时刻不能有多种实例状态，即【单态】（例如：操作系统的任务管理器、回收站、文件系统；应用程序的日志应用、网站的计时工具或ID(序号)生成器）；
 *  或者某个类只需要一个实例就够用了，即【单例】，多的实例不会有什么坏的影响，但也没什么作用，只是徒增资源消耗而已（例如：数据库连接池、线程池、web开发中读取配置文件）。

这时如果某个类在程序运行期间只有一个实例，就能实现上述需求（单例 / 单态）。

最简单的办法就是只实例化一次得到一个实例，自己记住，之后写代码的时候一直用它，不再实例化。问题是自己有可能忘了某个类已经实例化过了，而且别人想复用你的代码时也不知道你已经实例化过了，就很容易发生重复实例化，自然无法确保单例效果。为了解决这个问题，我们希望在这个类本身能够实现无论实例化多少次，每次返回的都是同一个实例的效果，这就是**单例模式**。这样后续使用这个类的人就无需关注是否已经实例化过，反正重复实例化得到的还是单例。

## 实例化过程原理 ##

类()：即obj = MyClass() ，执行MyClass的**元类**的\_\_call\_\_方法，如果没有使用metaclass指定元类，则默认元类为type  
实例()：即obj()，执行MyClass类的\_\_call\_\_方法

obj = MyClass() 这一实例化过程其实是调用其元类的\_\_call\_\_方法，如果未指定元类，则调用默认元类type的\_\_call\_\_方法，而这一方法是由type\_call函数（CPython 中的 C代码）来实现的，其实现的基本逻辑简化后相当于Python的以下代码：即先调用MyClass的\_\_new\_\_方法创建实例，如果实例符合2个条件，则调用MyClass的\_\_init\_\_方法对实例进行初始化。

def __call__(obj_type, *args, **kwargs):
        obj = obj_type.__new__(*args, **kwargs)
        if obj is not None and isinstance(obj, obj_type):
            obj.__init__(*args, **kwargs)
        return obj

由此可见，控制实例化过程的是3个特殊方法：

*  元类的\_\_call\_\_方法是实例化过程中最早调用的方法，它控制了类的\_\_new\_\_和\_\_init\_\_方法的调用
 *  类的\_\_new\_\_方法是第二个调用的方法，影响创建实例的具体过程
 *  类的\_\_init\_\_方法是最后调用的方法，影响实例的初始化

想要让MyClass成为单例模式，在实例化过程前加上条件判断就可以。问题是在哪里增加条件判断的代码？由于条件判断的代码所在位置不同，单例模式有多种实现方式。本文的重点就是比较分析这些实现方式的优缺点。

## 评价标准 ##

为了比较网上比较流行的Python实现单例模式的8种方法，提出以下评价标准：

*  将单例模式的代码独立封装为Singleton方便复用，MyClass及其子类SubClass无需关心单例模式的实现
 *  MyClass类有继承的基类OtherClass时不影响单例效果
 *  单例模式不影响MyClass作为基类被SubClass继承，且子类SubClass也是单例模式，即SubClass每次实例化得到都是同一个SubClass实例
 *  变量MyClass代表的是真正的MyClass类，能使用类属性、类方法
 *  type(obj) 返回的是真正的MyClass类
 *  type(obj) () 返回的也是单例，单例效果稳定
 *  有 lazy loading的效果，即导入模块时没有发生实例化，不消耗资源，等到需要使用时再实例化
 *  多线程并发环境下得到的也是单例

除了实现方式（一）、（二）以外，都使用以下测试代码：  
test.py

import threading
    import time
    from singleton_class import MyClass
    
    
    def print_task(obj=None, arg=1):
        if obj is None:
            obj = MyClass()
        before = obj.__dict__
        print('arg: %d, id(obj): %d' % (arg, id(obj)))
        print('arg: %d, before: %s' % (arg, before))
        obj.x = 'x_%d' % arg
        obj.a = 'a_%d' % arg
        if hasattr(obj, 'y'):
            obj.y = 'y_%d' % arg
        after = obj.__dict__
        print('arg: %d, after: %s' % (arg, after))
    
    
    if __name__ == '__main__':
        print('_____________________________MyClass MultiThreading Test______________________________________')
        for i in range(1, 11):
            t = threading.Thread(target=print_task, args=(None, i))
            t.start()
    
        time.sleep(4)
        print('_____________________________MyClass______________________________________')
        print('MyClass: %s, type(MyClass): %s' % (MyClass, type(MyClass)))
        try:
            print('MyClass.class_attribute(): %s' % MyClass.class_attribute)
            MyClass.class_func()
        except AttributeError:
            print('由于type(MyClass): %s，变量MyClass不能使用类属性、类方法' % type(MyClass))
    
        obj1 = MyClass()
        print_task(obj1, 1)
        obj2 = MyClass()
        print_task(obj2, 2)
        print('type(obj): %s' % type(obj1))
        obj3 = type(obj1)()
        print_task(obj3, 3)
    
        print('_____________________________SubClass______________________________________')
        try:
            class SubClass(MyClass):
                def __init__(self):
                    super(SubClass, self).__init__()
                    self.y = 'y_default'
    
            # # 实现方式（五）、（六）SubClass需改用以下代码
            # class SubClass(MyClass):
            #     def __init__(self):
            #         # __init__方法需避免重复初始化成员变量
            #         if not self._initialed:
            #             super(SubClass, self).__init__()
            #             self.y = 'y_default'
            #             self._initialed = True
    
            print('SubClass: %s, type(SubClass): %s' % (SubClass, type(SubClass)))
            print('SubClass.class_attribute(): %s' % SubClass.class_attribute)
            SubClass.class_func()
            sub_obj1 = SubClass()
            print_task(sub_obj1, 11)
            sub_obj2 = SubClass()
            print_task(sub_obj2, 12)
            print('type(sub_obj): %s' % type(sub_obj1))
            sub_obj3 = type(sub_obj1)()
            print_task(sub_obj3, 13)
        except TypeError:
            print('由于type(MyClass): %s，变量MyClass不能作为基类被继承' % type(MyClass))

## （一）使用类方法 getInstance 作为获取实例的接口 ##

此实现方式将条件判断的代码放在了类方法 getInstance 中，必须调用类方法 getInstance 作为获取实例的接口才能获得单例，如果使用 obj = MyClass() 这种常规方式，则获取到的不是单例，非常不实用，就不测试分析了，直接跳过。

class MyClass(object):
        _instance = None
    
        def __init__(self):
            self.x = 0
    
        @classmethod
        def get_instance(cls):
            if cls._instance is None:
                cls._instance = cls()
            return cls._instance

## （二）使用模块（同名实例替换类变量） ##

此实现方式没有增加条件判断的代码，而是借助了模块的单例特性，确保只有一个实例存在。  
[为什么Python模块就是天然的单例模式？][Python]

由于在程序运行期间模块只装载一次，并且模块A中的全局变量a绑定成了模块的属性，即A.a只有一个。如果A.a代表的是实例，并且切断了其他实例化的途径，则该类的实例就只有一个。

在声明 MyClass 类之后直接实例化一个单例保存在同名的全局变量 MyClass 中，即MyClass = MyClass()，这样变量 MyClass 代表的就是一个实例，不是类，也就不能通过 obj = MyClass() 这行代码进行实例化，会报错。为了不让这个这行代码报错，给MyClass类增加一个\_\_call\_\_方法（使得实例可以向函数一样通过 () 被调用），返回实例本身。这样每次通过 obj = MyClass() 这行代码进行“实例化”时，并没有真正进行实例化，而是调用了实例的\_\_call\_\_方法，返回实例本身，从而实现了单例模式。

singleton\_class.py

import time
    
    
    class Singleton(object):
        # 给单例类增加一个__call__方法，返回实例本身
        def __call__(self, *args, **kwargs):
            return self
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    class MyClass(Singleton, OtherClass):
        class_attribute = 'class_default'
    
        def __init__(self):
            time.sleep(1)
            # 注意：由于模块装载后，变量 MyClass 代表的是实例，不是类，不能使用super(MyClass, self).__init__()
            # 要获得真实的MyClass类，需使用__class__
            super(__class__, self).__init__()
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')
    
    # 同名实例替换类变量
    MyClass = MyClass()

test.py

import threading
    import time
    
    
    def print_task(obj, arg):
        before = obj.__dict__
        print('arg: %d, id(obj): %d' % (arg, id(obj)))
        print('arg: %d, before: %s' % (arg, before))
        obj.x = 'x_%d' % arg
        obj.a = 'a_%d' % arg
        if hasattr(obj, 'y'):
            obj.y = 'y_%d' % arg
        after = obj.__dict__
        print('arg: %d, after: %s' % (arg, after))
    
    
    def task(arg):
        print('arg: %d before import' % arg)
        # import语句是线程安全的，即使多线程并发导入同一个模块，也不会重复装载模块
        from singleton_class import MyClass
        print_task(MyClass(), arg)
    
    
    if __name__ == '__main__':
        print('_____________________________MyClass MultiThreading Test______________________________________')
        for i in range(1, 11):
            t = threading.Thread(target=task, args=(i, ))
            t.start()
    
        time.sleep(2)
    
        from ingleton_class import MyClass
        print('_____________________________MyClass______________________________________')
        print('type(MyClass): %s' % type(MyClass))
        print('MyClass.class_attribute(): %s' % MyClass.class_attribute)
        MyClass.class_func()
    
        obj1 = MyClass()
        print_task(obj1, 1)
        obj2 = MyClass()
        print_task(obj2, 2)
        obj3 = type(obj1)()
        print_task(obj3, 3)
    
    	print('_____________________________SubClass______________________________________')
        # 注意：变量MyClass代表的是实例，不是类，不能直接用变量MyClass作为基类，而需使用MyClass.__class__作为基类
        class SubClass(MyClass.__class__):
            def __init__(self):
                # 由于模块装载后，变量 SubClass 代表的是实例，不是类，不能使用super(SubClass, self).__init__()
                # 要获得真实的SubClass类，需使用__class__
                super(__class__, self).__init__()
                self.y = 'y_default'
    
        # 同名实例替换类变量
        SubClass = SubClass()
        
        print('SubClass: %s, type(SubClass): %s' % (SubClass, type(SubClass)))
        print('SubClass.class_attribute(): %s' % SubClass.class_attribute)
        SubClass.class_func()
        sub_obj1 = SubClass()
        print_task(sub_obj1, 11)
        sub_obj2 = SubClass()
        print_task(sub_obj2, 12)
        print('type(sub_obj): %s' % type(sub_obj1))
        sub_obj3 = type(sub_obj1)()
        print_task(sub_obj3, 13)

输出：  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass MultiThreading Test\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
arg: 1 before import  
arg: 2 before import  
arg: 3 before import  
arg: 4 before import  
arg: 5 before import  
arg: 6 before import  
arg: 7 before import  
arg: 8 before import  
arg: 9 before import  
arg: 10 before import  
arg: 1, id(obj): 40451880  
arg: 1, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 40451880  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 3, id(obj): 40451880  
arg: 3, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, id(obj): 40451880  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 5, id(obj): 40451880  
arg: 5, before: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 5, after: \{‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, id(obj): 40451880  
arg: 6, before: \{‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, after: \{‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 4, before: \{‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 4, after: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 7, id(obj): 40451880  
arg: 8, id(obj): 40451880  
arg: 8, before: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 7, before: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 7, after: \{‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, after: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, id(obj): 40451880  
arg: 9, before: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 10, id(obj): 40451880  
arg: 10, before: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 10, after: \{‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
arg: 9, after: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
MyClass: <singleton\_class.MyClass object at 0x0000000002693F28>, type(MyClass): <class ‘singleton\_class.MyClass’>  
MyClass.class\_attribute(): class\_default  
class function  
arg: 1, id(obj): 40451880  
arg: 1, before: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 40451880  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
type(obj): <class ‘singleton\_class.MyClass’>  
arg: 3, id(obj): 40101928  
arg: 3, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ SubClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
SubClass: <\_\_ main\_\_.SubClass object at 0x00000000026752E8>, type(SubClass): <class ‘\_\_ main\_\_.SubClass’>  
SubClass.class\_attribute(): class\_default  
class function  
arg: 11, id(obj): 40325864  
arg: 11, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 11, after: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, id(obj): 40325864  
arg: 12, before: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, after: \{‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
type(sub\_obj): <class ‘\_\_ main\_\_.SubClass’>  
arg: 13, id(obj): 40326032  
arg: 13, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 13, after: \{‘a’: ‘a\_13’, ‘x’: ‘x\_13’, ‘y’: ‘y\_13’\}

优点：

*  （核心优点）无需设置双重校验锁，自动实现在多线程并发环境下仍然是单例，原因是实例化发生在模块装载时，而import语句是线程安全的，即使多线程并发导入同一个模块，也不会重复装载模块，从而确保了只有一个实例存在
 *  MyClass类有继承的基类OtherClass时不影响单例效果
 *  变量MyClass代表的是MyClass类的实例，能使用类属性、类方法
 *  type(obj) 返回的是真正的MyClass类

缺点：

*  单例模式的代码不能完全独立封装，MyClass类及其子类SubClass为了实现单例模式，必须注意使用同名实例替换类变量
 *  单例模式影响MyClass作为基类被SubClass继承，因为变量MyClass代表的是实例，不是类，不能直接用变量MyClass作为基类，而需使用MyClass.\_\_class\_\_作为基类
 *  通过obj3 = type(obj1)() 得到的实例 obj3 不是单例，单例效果不稳定
 *  没有达到lazy loading的效果，在装载模块时就完成实例化了

## （三）使用函数装饰器 ##

此实现方式将MyClass这个变量替换为函数装饰器，从而可以在装饰器中进行条件判断。由于装饰器只是替换了MyClass这个变量，真正的实例化过程并未开始，当符合条件判断时，只需通过 obj = MyClass() 这种常规方式完成实例化即可。

singleton\_class.py

import threading
    import time
    
    
    # 写法1
    def Singleton(cls):
        _instance = dict()
        _instance_lock = threading.Lock()
    
        def _wrapper(*args, **kargs):
            # 外层校验是为了避免单例已产生后，线程还要拿锁，浪费锁资源
            if cls not in _instance:
                with _instance_lock:
                    # 内层校验是单例逻辑的条件判断，必须放在锁内，是为了避免线程在等锁的过程中单例已产生
                    if cls not in _instance:
                        _instance[cls] = cls(*args, **kargs)
            return _instance[cls]
    
        return _wrapper
    
    # # 写法2
    # def Singleton(cls):
    #     _instance = None
    #     _instance_lock = threading.Lock()
    #
    #     def _wrapper(*args, **kargs):
    #         nonlocal _instance
    #         # 外层校验是为了避免单例已产生后，线程还要拿锁，浪费锁资源
    #         if _instance is None:
    #             with _instance_lock:
    #                 # 内层校验是单例逻辑的条件判断，必须放在锁内，是为了避免线程在等锁的过程中单例已产生
    #                 if _instance is None:
    #                     _instance = cls(*args, **kargs)
    #         return _instance
    #
    #     return _wrapper
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    @Singleton
    class MyClass(OtherClass):
        class_attribute = 'class_default'
    
        def __init__(self):
            time.sleep(1)
            # 注意：经过装饰后的变量 MyClass 代表的是函数，不是类，不能使用super(MyClass, self).__init__()
            # 要获得真实的MyClass类，需使用__class__
            super(__class__, self).__init__()
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')

优点：

*  将单例模式的代码独立封装，MyClass类无需关心单例模式的实现
 *  MyClass有继承的基类OtherClass时不影响单例效果
 *  type(obj) 返回的是真正的MyClass类
 *  有 lazy loading 效果

缺点：

*  单例模式导致MyClass不能作为基类被SubClass继承
 *  经过装饰后的变量MyClass代表的是一个\_wrapper函数，而不是真正的MyClass类，不能使用MyClass的类属性、类方法
 *  obj3 = type(obj1)() 得到的实例 obj3 不是单例，单例效果不稳定
 *  需手动设置双重校验锁，才能在保证多线程并发环境下得到的也是单例

## （四）使用类装饰器 ##

此实现方式与（三）使用函数装饰器非常相似，没有本质区别，只不过装饰器的写法不同。  
singleton\_class.py

import threading
    import time
    
    
    class Singleton(object):
        _instance_lock = threading.Lock()
    
        def __init__(self, cls):
            self._cls = cls
            self._instance = None
    
        def __call__(self, *args, **kwargs):
            if self._instance is None:
                with Singleton._instance_lock:
                    if self._instance is None:
                        self._instance = self._cls(*args, **kwargs)
            return self._instance
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    @Singleton
    class MyClass(OtherClass):
        class_attribute = 'class_default'
    
        def __init__(self):
            time.sleep(1)
            # 注意：经过装饰后的变量 MyClass 代表的是实例，不是类，不能使用super(MyClass, self).__init__()
            # 要获得真实的MyClass类，需使用__class__
            super(__class__, self).__init__()
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')

优缺点与函数装饰器相同，区别在于经过装饰后的变量MyClass代表的是Singleton类（装饰器）的实例，它也不代表真正的MyClass类。

## （五）使用装饰器返回类 ##

在实现方式（三）、（四）中，经过装饰后的变量MyClass代表的都不是类，不能作为基类被SubClass继承，为了解决这个问题，考虑使用装饰器返回类的实现方式。

由实例化过程原理分析，我们知道了：类的\_\_new\_\_方法是第二个调用的方法，影响创建实例的具体过程；类的\_\_init\_\_方法是最后调用的方法，影响实例的初始化。

那么，通过在类的\_\_new\_\_方法增加条件判断的代码，就能实现单例模式。但是没这么简单，必须要注意三个问题：

1.  每次调用\_\_new\_\_方法之后，会紧接着调用\_\_init\_\_方法。所以，必须给出一个标志，避免\_\_init\_\_方法重复调用导致成员变量被默认值覆盖。
2.  多线程并发环境下，如果MyClass类的\_\_init\_\_方法中有耗时操作，则装饰器内的\_\_init\_\_方法也要加双重校验锁。
3.  经过装饰后的变量MyClass代表的是class\_wrapper类，从而SubClass继承的就是class\_wrapper类，但SubClass真正想要继承的是MyClass类。于是，为了能够让SubClass继承到MyClass类，class\_wrapper类必须继承于MyClass类。

singleton\_class.py

import threading
    import time
    
    
    def Singleton(_cls):
    	# 为了能够让SubClass继承到MyClass类，class_wrapper类必须继承于MyClass类
        class class_wrapper(_cls):
        	# 由于class_wrapper的类属性_instance被所有单例类共享，为保证各单例类之间相互独立，_instance需使用可变数据类型（例如：字典）
            _instance = dict()
            _instance_lock = threading.Lock()
    
            def __new__(cls):
                if cls not in class_wrapper._instance.keys():
                    with class_wrapper._instance_lock:
                        if cls not in class_wrapper._instance.keys():
                            class_wrapper._instance[cls] = super(class_wrapper, cls).__new__(cls)
                            # 需给出一个标志，从而__init__方法可以根据此标志避免重复初始化成员变量
                            class_wrapper._instance[cls]._intialed = False
                return class_wrapper._instance[cls]
    
            def __init__(self):
                # __init__方法需避免重复初始化成员变量，并且加双重校验锁
                if not self._intialed:
                    with class_wrapper._instance_lock:
                        if not self._intialed:
                            super(class_wrapper, self).__init__()
                            self._intialed = True
    
        class_wrapper.__name__ = _cls.__name__
        return class_wrapper
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    @Singleton
    class MyClass(OtherClass):
        class_attribute = 'class_default'
    
        def __init__(self):
            time.sleep(1)
            # 注意：经过装饰后的变量 MyClass 代表的是class_wrapper类，而不是真实的MyClass类，不能使用super(MyClass, self).__init__()
            # 要获得真实的MyClass类，需使用__class__
            super(__class__, self).__init__()
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')

注意： test.py中的SubClass需改为以下代码

# 实现方式（五）、（六）SubClass需改用以下代码
            class SubClass(MyClass):
                def __init__(self):
                    # __init__方法需避免重复初始化成员变量
                    if not self._initialed:
                        super(SubClass, self).__init__()
                        self.y = 'y_default'
                        self._initialed = True

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9

输出：  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass MultiThreading Test\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
arg: 1, id(obj): 39289072  
arg: 1, before: \{’\_ intialed’: True, ‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 1, after: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39289072  
arg: 2, before: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, id(obj): 39289072  
arg: 3, before: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, id(obj): 39289072  
arg: 4, before: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, after: \{’\_ intialed’: True, ‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, id(obj): 39289072  
arg: 5, before: \{’\_ intialed’: True, ‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, after: \{’\_ intialed’: True, ‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, id(obj): 39289072  
arg: 6, before: \{’\_ intialed’: True, ‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, after: \{’\_ intialed’: True, ‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, id(obj): 39289072  
arg: 7, before: \{’\_ intialed’: True, ‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, after: \{’\_ intialed’: True, ‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, id(obj): 39289072  
arg: 8, before: \{’\_ intialed’: True, ‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, after: \{’\_ intialed’: True, ‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, id(obj): 39289072  
arg: 9, before: \{’\_ intialed’: True, ‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, after: \{’\_ intialed’: True, ‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, id(obj): 39289072  
arg: 10, before: \{’\_ intialed’: True, ‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, after: \{’\_ intialed’: True, ‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
MyClass: <class ‘singleton\_class.Singleton.< locals >.class\_wrapper’>, type(MyClass): <class ‘type’>  
MyClass.class\_attribute(): class\_default  
class function  
arg: 1, id(obj): 39289072  
arg: 1, before: \{’\_ intialed’: True, ‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
arg: 1, after: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39289072  
arg: 2, before: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
type(obj): <class ‘singleton\_class.Singleton.< locals >.class\_wrapper’>  
arg: 3, id(obj): 39289072  
arg: 3, before: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ SubClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
SubClass: <class ‘\_\_ main\_\_.SubClass’>, type(SubClass): <class ‘type’>  
SubClass.class\_attribute(): class\_default  
class function  
arg: 11, id(obj): 39187120  
arg: 11, before: \{’\_ initialed’: True, ‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 11, after: \{’\_ initialed’: True, ‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, id(obj): 39187120  
arg: 12, before: \{’\_ initialed’: True, ‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, after: \{’\_ initialed’: True, ‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
type(sub\_obj): <class ‘\_\_ main\_\_.SubClass’>  
arg: 13, id(obj): 39187120  
arg: 13, before: \{’\_ initialed’: True, ‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
arg: 13, after: \{’\_ initialed’: True, ‘a’: ‘a\_13’, ‘x’: ‘x\_13’, ‘y’: ‘y\_13’\}

优点：

*  MyClass类无需关心单例模式的实现
 *  MyClass有继承的基类OtherClass时不影响单例效果
 *  单例模式不影响MyClass作为基类被继承，且子类SubClass也是单例模式，即SubClass每次实例化得到都是同一个SubClass实例
 *  经过装饰后的变量MyClass代表了class\_wrapper类，它是MyClass类的子类，从而能使用MyClass类的类属性、类方法
 *  通过obj3 = type(obj1)() 得到的实例也是单例，单例效果稳定
 *  有 lazy loading 效果

缺点：

*  单例模式的代码不能完全独立封装，子类SubClass需关心单例模式的实现（必须注意不能重载\_\_new\_\_方法，否则SubClass不是单例模式；\_\_init\_\_方法需注意避免重复初始化成员变量）
 *  type(obj) 返回的是class\_wrapper类，不是真正的MyClass类，即obj实际上是class\_wrapper类的单例
 *  需手动设置双重校验锁，才能在保证多线程并发环境下得到的也是单例

## （六）使用基类 ##

在实现方式（五）中，经过装饰后的变量MyClass代表了class\_wrapper类，不是真正的MyClass类。为了解决这个问题，考虑使用基类的实现方式。

这种实现方式也是通过在类的\_\_new\_\_方法增加条件判断的代码。但是Singleton是基类，MyClass是子类，基类无法控制子孙类方法的调用，因此必须要注意三个问题：

1.  每次调用\_\_new\_\_方法之后，会紧接着调用\_\_init\_\_方法。所以，必须给出一个标志，避免\_\_init\_\_方法重复调用导致成员变量被默认值覆盖。
2.  基类Singleton无法控制子孙类方法的调用，如果子孙类有自己特殊的成员变量需要初始化，则\_\_init\_\_方法不能封装到基类Singleton中。
3.  多线程并发环境下，如果\_\_init\_\_方法中有耗时操作，则\_\_init\_\_方法也要加双重校验锁。

singleton\_class.py

import threading
    import time
    
    
    class Singleton(object):
    	# 由于Singleton的类属性_instance被所有单例类共享，为保证各单例类之间相互独立，_instance需使用可变数据类型（例如：字典）
        _instance = dict()
        _instance_lock = threading.Lock()
    
        def __new__(cls, *args, **kwargs):
            if cls not in Singleton._instance.keys():
                with Singleton._instance_lock:
                    if cls not in Singleton._instance.keys():
                        Singleton._instance[cls] = super(Singleton, cls).__new__(cls)
                        # 需给出一个标志，从而__init__方法可以根据此标志避免重复初始化成员变量
                        Singleton._instance[cls]._intialed = False
            return Singleton._instance[cls]
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    class MyClass(Singleton, OtherClass):
        class_attribute = 'class_default'
    
        def __init__(self):
            # __init__方法需避免重复初始化成员变量，并且加双重校验锁
            if not self._initialed:
                with self._instance_lock:
                    if not self._initialed:
                        super(MyClass, self).__init__()
                        time.sleep(1)
                        self.x = 'x_default'
                        self._initialed = True
    
    
        @classmethod
        def class_func(cls):
            print('class function')

注意： test.py中的SubClass需改为以下代码

输出：  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass MultiThreading Test\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
arg: 1, id(obj): 39579888  
arg: 1, before: \{’\_ intialed’: True, ‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 1, after: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39579888  
arg: 2, before: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, id(obj): 39579888  
arg: 3, before: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, id(obj): 39579888  
arg: 4, before: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, after: \{’\_ intialed’: True, ‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, id(obj): 39579888  
arg: 5, before: \{’\_ intialed’: True, ‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, after: \{’\_ intialed’: True, ‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, id(obj): 39579888  
arg: 6, before: \{’\_ intialed’: True, ‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, after: \{’\_ intialed’: True, ‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, id(obj): 39579888  
arg: 7, before: \{’\_ intialed’: True, ‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, after: \{’\_ intialed’: True, ‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, id(obj): 39579888  
arg: 8, before: \{’\_ intialed’: True, ‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 9, id(obj): 39579888  
arg: 9, before: \{’\_ intialed’: True, ‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, after: \{’\_ intialed’: True, ‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, after: \{’\_ intialed’: True, ‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, id(obj): 39579888  
arg: 10, before: \{’\_ intialed’: True, ‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, after: \{’\_ intialed’: True, ‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
***MyClass***\_\_\_\_\_\_\_\_\_  
MyClass: <class ‘singleton\_class.MyClass’>, type(MyClass): <class ‘type’>  
MyClass.class\_attribute(): class\_default  
class function  
arg: 1, id(obj): 39579888  
arg: 1, before: \{’\_ intialed’: True, ‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
arg: 1, after: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39579888  
arg: 2, before: \{’\_ intialed’: True, ‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
type(obj): <class ‘singleton\_class.MyClass’>  
arg: 3, id(obj): 39579888  
arg: 3, before: \{’\_ intialed’: True, ‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{’\_ intialed’: True, ‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ SubClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
SubClass: <class ‘\_\_ main\_\_.SubClass’>, type(SubClass): <class ‘type’>  
SubClass.class\_attribute(): class\_default  
class function  
arg: 11, id(obj): 39974392  
arg: 11, before: \{’\_ intialed’: True, ‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 11, after: \{’\_ intialed’: True, ‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, id(obj): 39974392  
arg: 12, before: \{’\_ intialed’: True, ‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, after: \{‘*intialed’: True, ‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
type(sub\_obj): <class '*\_ main\_\_.SubClass’>  
arg: 13, id(obj): 39974392  
arg: 13, before: \{’\_ intialed’: True, ‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
arg: 13, after: \{’\_ intialed’: True, ‘a’: ‘a\_13’, ‘x’: ‘x\_13’, ‘y’: ‘y\_13’\}

优点：

*  MyClass类有继承的基类OtherClass时不影响单例效果（前提条件：Singleton需作为第一基类）
 *  单例模式不影响MyClass类作为基类被继承，且子类SubClass也是单例模式，即SubClass每次实例化得到都是同一个SubClass实例
 *  变量MyClass代表的是真正的MyClass类，能使用类属性、类方法
 *  type(obj) 返回的是真正的MyClass类
 *  通过obj3 = type(obj1)() 得到的实例也是单例，单例效果稳定
 *  有 lazy loading 效果

缺点：

*  单例模式的代码不能完全独立封装，MyClass类、SubClass类需关心单例模式的实现（必须注意不重载\_\_new\_\_方法，否则不是单例；\_\_init\_\_方法需避免重复初始化成员变量；Singleton需作为第一基类）
 *  需手动设置双重校验锁，才能在保证多线程并发环境下得到的也是单例

## （七）使用元类 ##

实现方式（五）、（六）都是通过在类的\_\_new\_\_方法中增加条件判断的代码来实现单例模式的，导致单例模式的代码不能完全独立封装。

回顾实例化过程的原理，元类的\_\_call\_\_方法是实例化过程中最早调用的方法，从而可以在元类的\_\_call\_\_方法中增加条件判断。

需要注意的是，由于此时实例化过程已开始，当符合条件判断时，需通过super函数调用父元类type的\_\_call\_\_方法完成实例化。

singleton\_class.py

import threading
    import time
    
    # 写法1
    # 元类Singleton不保存所有单例类的实例，各单例类通过自己的类属性cls._instance保存单例
    class Singleton(type):
        _instance_lock = threading.Lock()
    
        # 元类的__init__方法负责在类创建后初始化类属性
        def __init__(cls, *args, **kwargs):
            # 虽然子类SubClass创建时继承了基类MyClass的类属性_instance，但是会在此处被重置为None，从而SubClass也是单例模式
            cls._instance = None
            super(Singleton, cls).__init__(*args, **kwargs)
    
        def __call__(cls, *args, **kwargs):
            # 外层校验是为了避免单例已产生后，线程还要拿锁，浪费锁资源
            if cls._instance is None:
                with Singleton._instance_lock:
                    # 内层校验是单例逻辑的条件判断，必须放在锁内，是为了避免线程在等锁的过程中单例已产生
                    if cls._instance is None:
                    	# 通过super函数调用父元类type的__call__方法完成实例化
                        cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
            return cls._instance
    
    # # 写法2
    # # 元类属性_instances保存了所有单例类的实例，各单例类本身没有保存单例，各单例类也不会继承元类属性
    # class Singleton(type):
    #     _instances = dict()
    #     _instance_lock = threading.Lock()
    # 
    #     def __call__(cls, *args, **kwargs):
    #         if cls not in cls._instances.keys():
    #             with Singleton._instance_lock:
    #                 if cls not in cls._instances.keys():
    #                     cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
    #         return cls._instances[cls]
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    class MyClass(OtherClass, metaclass=Singleton):
        class_attribute = 'class_default'
    
        def __init__(self):
            time.sleep(1)
            super(MyClass, self).__init__()
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')

输出：  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass MultiThreading Test\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
arg: 1, id(obj): 39340128  
arg: 1, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 2, id(obj): 39340128  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, id(obj): 39340128  
arg: 3, before: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, id(obj): 39340128  
arg: 4, before: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, after: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, id(obj): 39340128  
arg: 5, before: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 5, after: \{‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, id(obj): 39340128  
arg: 6, before: \{‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 6, after: \{‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, id(obj): 39340128  
arg: 7, before: \{‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 7, after: \{‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, id(obj): 39340128  
arg: 8, before: \{‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, after: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, id(obj): 39340128  
arg: 9, before: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, after: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, id(obj): 39340128  
arg: 10, before: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, after: \{‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
***MyClass***\_\_\_\_\_\_\_\_\_  
MyClass: <class ‘singleton\_class.MyClass’>, type(MyClass): <class ‘singleton\_class.Singleton’>  
MyClass.class\_attribute(): class\_default  
class function  
arg: 1, id(obj): 39340128  
arg: 1, before: \{‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39340128  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
type(obj): <class ‘singleton\_class.MyClass’>  
arg: 3, id(obj): 39340128  
arg: 3, before: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
***SubClass***\_\_\_\_\_\_\_\_\_  
SubClass: <class ‘\_\_ main\_\_.SubClass’>, type(SubClass): <class ‘singleton\_class.Singleton’>  
SubClass.class\_attribute(): class\_default  
class function  
arg: 11, id(obj): 39982808  
arg: 11, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 11, after: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, id(obj): 39982808  
arg: 12, before: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, after: \{‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
type(sub\_obj): <class ‘\_\_ main\_\_.SubClass’>  
arg: 13, id(obj): 39982808  
arg: 13, before: \{‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
arg: 13, after: \{‘a’: ‘a\_13’, ‘x’: ‘x\_13’, ‘y’: ‘y\_13’\}  
优点：

*  将单例模式的代码独立封装，MyClass及其子类SubClass无需关心单例模式的实现
 *  MyClass类有继承的基类OtherClass时不影响单例效果
 *  单例模式不影响MyClass类作为基类被继承，且子类SubClass也是单例模式，即SubClass每次实例化得到都是同一个SubClass实例
 *  变量MyClass代表的是真正的MyClass类，能使用类属性、类方法
 *  type(obj) 返回的是真正的MyClass类
 *  通过obj3 = type(obj1)() 得到的实例也是单例，单例效果稳定
 *  有 lazy loading 效果

缺点：

*  需手动设置双重校验锁，才能在保证多线程并发环境下得到的也是单例

## （八）Borg单态模式（所有实例共享状态） ##

上述7种实现方式都是通过确保只有一个实例存在，从而实现单态的，而Borg模式的思路是"实例的唯一性并不是重要的，我们应该关注的是实例的状态，只要所有的实例共享状态，行为一致，那就达到了单例的目的"。通过Borg模式，可以创建任意数量的实例，但因为它们共享状态，从而实现了单态。所以严格来说，Borg模式不是单例模式，而是单态模式。

Borg模式代码的核心是，将所有实例的属性字典都指向同一个内存地址，这样就能实现虽然实例有多个，但属性字典只有一个，从而所有的实例共享状态。

需要注意的是，实例可以有多个，所以\_\_new\_\_方法的调用不限次数；但初始化成员变量只能有一次，所以\_\_init\_\_方法只能调用一次。由于元类的\_\_call\_\_方法能够控制这两个方法的调用，所以采用元类封装Borg模式的代码。

import threading
    import time
    
    
    class Singleton(type):
        _instance_lock = threading.Lock()
    
        # 元类的__init__方法负责在类创建后初始化类属性
        def __init__(cls, *args, **kwargs):
            cls._shared_state = dict()
            cls._initialed = False
            super(Singleton, cls).__init__(*args, **kwargs)
    
        def __call__(cls, *args, **kwargs):
            obj = cls.__new__(cls, *args, **kwargs)
            # 将所有实例的属性字典都指向同一个内存地址，虽然实例有多个，但属性字典只有一个，从而实现所有实例共享状态
            obj.__dict__ = cls._shared_state
            if not cls._initialed and obj is not None and isinstance(obj, cls):
                with Singleton._instance_lock:
                    if not cls._initialed and obj is not None and isinstance(obj, cls):
                        obj.__init__(*args, **kwargs)
                        cls._initialed = True
            return obj
    
    
    class OtherClass(object):
        def __new__(cls):
            return super(OtherClass, cls).__new__(cls)
    
        def __init__(self):
            self.a = 'a_default'
            super(OtherClass, self).__init__()
    
    
    class MyClass(OtherClass, metaclass=Singleton):
        class_attribute = 'class_attribute'
    
        def __init__(self):
            super(MyClass, self).__init__()
            time.sleep(1)
            self.x = 'x_default'
    
        @classmethod
        def class_func(cls):
            print('class function')

输出：  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass MultiThreading Test\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
arg: 1, id(obj): 40301288  
arg: 1, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’\}  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 40302072  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 3, id(obj): 40302296  
arg: 3, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, id(obj): 40302520  
arg: 5, id(obj): 40302744  
arg: 5, before: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 4, before: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
arg: 6, id(obj): 40302968  
arg: 4, after: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 6, before: \{‘a’: ‘a\_4’, ‘x’: ‘x\_4’\}  
arg: 6, after: \{‘a’: ‘a\_6’, ‘x’: ‘x\_6’\}  
arg: 5, after: \{‘a’: ‘a\_5’, ‘x’: ‘x\_5’\}  
arg: 7, id(obj): 40303192  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 7, before: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 7, after: \{‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, id(obj): 40303416  
arg: 8, before: \{‘a’: ‘a\_7’, ‘x’: ‘x\_7’\}  
arg: 8, after: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, id(obj): 40303640  
arg: 9, before: \{‘a’: ‘a\_8’, ‘x’: ‘x\_8’\}  
arg: 9, after: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, id(obj): 40303864  
arg: 10, before: \{‘a’: ‘a\_9’, ‘x’: ‘x\_9’\}  
arg: 10, after: \{‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ MyClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
MyClass: <class ‘singleton\_class.MyClass’>, type(MyClass): <class ‘singleton\_class.Singleton’>  
MyClass.class\_attribute(): class\_attribute  
class function  
arg: 1, id(obj): 39514800  
arg: 1, before: \{‘a’: ‘a\_10’, ‘x’: ‘x\_10’\}  
arg: 1, after: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, id(obj): 39945160  
arg: 2, before: \{‘a’: ‘a\_1’, ‘x’: ‘x\_1’\}  
arg: 2, after: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
type(obj): <class ‘singleton\_class.MyClass’>  
arg: 3, id(obj): 39667864  
arg: 3, before: \{‘a’: ‘a\_2’, ‘x’: ‘x\_2’\}  
arg: 3, after: \{‘a’: ‘a\_3’, ‘x’: ‘x\_3’\}  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ SubClass\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
SubClass: <class ‘\_\_ main\_\_.SubClass’>, type(SubClass): <class ‘singleton\_class.Singleton’>  
SubClass.class\_attribute(): class\_attribute  
class function  
arg: 11, id(obj): 40303584  
arg: 11, before: \{‘a’: ‘a\_default’, ‘x’: ‘x\_default’, ‘y’: ‘y\_default’\}  
arg: 11, after: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, id(obj): 40303360  
arg: 12, before: \{‘a’: ‘a\_11’, ‘x’: ‘x\_11’, ‘y’: ‘y\_11’\}  
arg: 12, after: \{‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
type(sub\_obj): <class ‘\_\_ main\_\_.SubClass’>  
arg: 13, id(obj): 40303248  
arg: 13, before: \{‘a’: ‘a\_12’, ‘x’: ‘x\_12’, ‘y’: ‘y\_12’\}  
arg: 13, after: \{‘a’: ‘a\_13’, ‘x’: ‘x\_13’, ‘y’: ‘y\_13’\}

优点：

*  将单态模式的代码独立封装，MyClass及其子类SubClass无需关心单态模式的实现
 *  MyClass类有继承的基类OtherClass时不影响单态效果
 *  单态模式不影响MyClass类作为基类被继承，且子类SubClass也是单态模式，即SubClass的所有实例都共享SubClass的单态
 *  变量MyClass代表的是真正的MyClass类，能使用类属性、类方法
 *  type(obj) 返回的是真正的MyClass类
 *  通过obj3 = type(obj1)() 得到的实例也是单态
 *  有 lazy loading 效果

缺点：

*  虽然所有实例的属性都指向同一个内存地址，但每个实例本身都分配了一个内存地址，这也是一种资源浪费
 *  需手动设置双重校验锁，才能在保证多线程并发环境下得到的也是单态

## 参考文档 ##

1.  [理解 Python对象实例化][Python 1]
2.  [stackoverflow：Python method-wrapper type?][stackoverflow_Python method-wrapper type]
3.  [类和对象的创建过程（元类，\_\_ new\_\_,\_\_ init\_\_,\_\_ call\_\_）][new_ init_ call]
4.  [类的继承、元类][Link 1]
5.  [stackoverflow：is-there-a-simple-elegant-way-to-define-singletons][stackoverflow_is-there-a-simple-elegant-way-to-define-singletons]
6.  [Python中的单例模式的几种实现方式的及优化][Python 2]
7.  [5种Python单例模式的实现方式][5_Python]
8.  [Python单体模式的几种常见实现方法详解][Python 3]
9.  [Python 编程，应该养成哪些好的习惯？][Python 4]
10. [Python单例模式(Singleton)的N种实现][Python_Singleton_N]
11. [单例模式的常见应用场景][Link 2]
12. [深入理解设计模式（一）：单例模式][Link 3]
13. [【Python】闭包的实现原理，如何在内部函数修改外部函数的变量][Python 5]
14. [什么是面向对象？为什么要用面向对象编程？][Link 4]
15. [怎么从本质上理解面向对象的编程思想？][Link 5]

[Python]: https://blog.csdn.net/u012324798/article/details/104136270
[Python 1]: https://liqiang.io/post/understanding-python-class-instantiation
[stackoverflow_Python method-wrapper type]: https://stackoverflow.com/questions/10401935/python-method-wrapper-type
[new_ init_ call]: https://www.cnblogs.com/huchong/p/8260151.html#_label1
[Link 1]: https://bbs.csdn.net/topics/390510751
[stackoverflow_is-there-a-simple-elegant-way-to-define-singletons]: https://stackoverflow.com/questions/31875/is-there-a-simple-elegant-way-to-define-singletons/31887#31887
[Python 2]: https://www.cnblogs.com/huchong/p/8244279.html
[5_Python]: https://www.jb51.net/article/78063.htm
[Python 3]: https://www.jb51.net/article/119809.htm
[Python 4]: https://www.zhihu.com/question/28966220/answer/130285330
[Python_Singleton_N]: https://segmentfault.com/a/1190000016497271
[Link 2]: https://www.cnblogs.com/gmq-sh/p/5948379.html
[Link 3]: https://www.cnblogs.com/xuwendong/p/9633985.html
[Python 5]: https://blog.csdn.net/mydistance/article/details/86554904
[Link 4]: https://blog.csdn.net/u011700168/article/details/79161724
[Link 5]: https://www.zhihu.com/question/305042684/answer/550196442