Python中的单例模式（单例模式的代码实现）

"""
Python单例模式一种常见的软件设计模式。在它的核心结果中只包含一个被称为单例类的特殊类。
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便的对实例个数的控制
节约系统资源。

如果希望在系统中某个类的对象只能存在一个，单例模式就是最好的解决方案。

单例模式的要点有三个：
1.某个类只能有一个实例
2.它必须自行创建这个实例
3.它必须自行向整个系统提供这个实例

从具体实现角度来说，就是以下三点：
1.单例模式的类只提供了私有的构造函数
2.类定义中含有一个该类的静态私有对象
3.该类提供了一个静态的共有函数用于创建或获取它本身的静态私有对象。

应用场景：
1.一些资源管理器常常设计成单例模式

2.在计算机系统中，需要管理的资源包括软件外部资源，比如每台计算机可以有若干个打印机，
但是只能有一个Printer Spooler(打印机后台处理程序),以避免两个打印机同时输出到打印机中。每台计算机可以有若干传真机卡，
但是只应该有一个软件复制管理传真卡，以避免一个通信端口同时被两个请求同时调用。

3.需要管理的资源包括软件内部，比如，大多数的软件都有一个或者多个文件存放系统配置。这样
的系统应当由要给对象来管理要给属性文件。

4.需要管理的软件内部资源也包括负责记录网站来访人数的部件，记录软件系统内部时间、出错信息的部件，
或是对系统的表现进行检查的部件等。其一，这些资源管理器构成必须只有要给实例；其二，它们必须自行初始化，
其三：允许整个系统访问自己。

5.在数据源配置的时候，调用只有一个实例对象。


"""
# 实现方式：
"""
方式一：
实现__new__方法，然后将类的一个实例绑定到类变量_instance上；如果cls._instance为None，则说明该类还
没有被实例化过，new一个该类的实例，并返回；如果cls._instance不为None，直接返回_instance，代码如下：

"""

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

class MyClass(Singleton):
    a=1
    b=2

one=MyClass()
two=MyClass()

# one和two完全相同，可以用id()，==，is检查
print(one.a)    # 1
print(two.b)
print(id(one))  # 1574221311568
print(id(two))  # 1574221311568
print(one == two)   # True
print(one is two)   # True

"""
常用方式：
python的单例模式__new__()在__init__()之前被调用，用于生产实例对象。利用这个方法和
类的属性的特点可以实现设计模式的单例模式。单例模式是指创建唯一对象，单例模式设计
的类只能实例化一个对象。
"""
class Singleton(object):
    __instance=None

    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if Singleton.__instance is None:
            Singleton.__instance=object.__new__(cls,*args, **kwargs)
        return Singleton.__instance

one=Singleton()
two=Singleton()
print(id(one))  # 1574221311568
print(id(two))  # 1574221311568
print(one == two)   # True
print(one is two)   # True


"""
升级方法：

class Singleton中的__init__在Myclass声明的时候被执行Myclass=Singleton()
Myclass()执行时，最先执行父类的__call__方法（object,Singleton都作为Myclass的父类，
根据深度优先算法，会执行Singleton中的__call__()，Singleton中的__call__()写了单例模式）
"""
class Singleton(type):

    def __init__(self, name, bases, dict):
        super(Singleton,self).__init__(name,bases, dict)
        self._instance = None

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super(Singleton,self).__call__(*args, **kwargs)
        return self._instance

class MyClass(object,metaclass=Singleton):
    a = 1

one=MyClass()
two=MyClass()
print(id(one))  # 1553247294800
print(id(two))  # 1553247294800
print(one == two)   # True
print(one is two)   # True


"""
经典方法：
使用python的装饰器（decorator）实现单例模式，这是一简便的方法；单例类本身的代码不是单例的，通过
装饰器使其单例化，代码如下：
"""

# 通过singleton在一个文件，MyClass3类在另一个文件，通过导包调用
def singleton(cls, *args, **kwargs):
    instances = {}

    def _singleton():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return _singleton


@singleton
class MyClass3(object):
    a = 1


one = MyClass3()
two = MyClass3()

print(id(one))  # 1800317071216
print(id(two))  # 1800317071216
print(one == two)  # True
print(one is two)  # True

总结:

1. 内容：保证一个类只有一个实例，并提供一个访问它的全局访问点。
2. 适用场景：当类只能有一个实例而且客户可以从一个众所周知的访问点访问它的时候
3. 优点：

• 对唯一实例的受控访问
• 单例相当于全局变量，但防止了命名空间被污染
• 与单例模式功能相似的概念：全局变量、静态变量（方法）

效果如下: