python实现单例模式详解 python实现单例模式详解

一、单例模式

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：

1、一个班级只有一个班主任。

2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

二、python实现单例模式错误的示范
在网上看到的一个例子是使用双检锁实现单例模式，这个方法通过重载python对象的__new__ 方法，使得每个类只能被new一次。代码如下：

import threadingclass Singleton(object): _instance_lock = threading.Lock()def __init__(self): passdef __new__(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = object.__new__(cls) return Singleton._instanceobj1 = Singleton() obj2 = Singleton() print(obj1,obj2)

上面的代码看似实现了单例模式，但是只是实现了一个单例模式的外壳，为什么这么说呢，我们在__init__函数里加一个打印语句看看。

import threadingclass Singleton(object): _instance_lock = threading.Lock()def __init__(self): ptint('__init__ is called.')def __new__(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = object.__new__(cls) return Singleton._instanceobj1 = Singleton() obj2 = Singleton() print(obj1,obj2)

运行一下我们就会发现 __init__ 函数调用了两次，这是这段代码最大的问题，每次调用类时 __init__ 函数都会调用一次。虽然类只会被new一次，但是类的属性却会在类的使用过程中被不断覆盖，所以上面的代码只做到了类的单例，但是不能做到属性的单例。
有人说既然这样我把属性全部放在 __new__ 函数里初始化不就行了，这个做法在功能上没有问题，但是却违反了单一职责原则，__new__ 函数并不是负责初始化属性的功能，__init__ 函数才是。
另外上面的代码中将 Singleton 硬编码到了代码中，使得这个类不能被继承，因为当子类调用父类的 __new__ 函数时返回的不是子类的类型。所以我们需要将 Singleton 改成 cls，__new__ 函数接受的类的type对象。
三、正确的示范
上面我们提到了 __init__ 函数调用多次的问题，也说明了直接在 __new__ 函数里初始化属性的问题，现在我们就来讨论一下如何正确的用 python实现单例模式。
【python实现单例模式详解】我们现在面临的问题就是如何让 __init__ 函数只调用一次，最简单的思路就是让 __init__ 函数和 __new__ 函数一样，也使用一个标志和双检锁来确保线程安全和只调用一次，修改后的代码如下：

import threadingclass Singleton(object): _lock = threading.Lock()def __init__(self): if not hasattr(self, '_init_flag'): with self._lock: if not hasattr(self, '_init_flag'): self._init_falg = True # 初始化属性 ptint('__init__ is called.')def __new__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): with cls._instance_lock: if not hasattr(cls, "_instance"): cls._instance = object.__new__(cls) return cls._instanceobj1 = Singleton() obj2 = Singleton() print(obj1,obj2)

现在我们的单例模式总算有点样子了，Singleton 类的 __new__ 和 __init__ 函数都只会调用一次,并且这些都是线程安全的。
但是这样还不够，按照现在的方法，我们每次要定义一个单例模式的类时都需要手动去修改 __init__ 函数和 __new__ 函数，这有点麻烦。如果我们用的是 Java的话那就没办法了，这些麻烦事必要的，但我们使用的语言是python！
四、使用装饰器实现单例模式
从上一步单例模式的实现来看，我们每次要做到就是修改 __init__ 函数和 __new__ 函数，这简直就是为装饰器量身定做的应用场景。我们可以使用装饰器来替换类的 __init__ 函数和 __new__ 函数，将类原来的函数放在双检锁内部执行。代码如下：

from functools import wraps import threadingdef singleton(): """ 单例模式装饰器 :return: """ # 闭包绑定线程锁 lock = threading.Lock() def decorator(cls): # 替换 __new__ 函数 instance_attr = '_instance' # 获取原来的__new__函数防止无限递归 __origin_new__ = cls.__new__ @wraps(__origin_new__) def __new__(cls_1, *args, **kwargs): if not hasattr(cls_1, instance_attr): with lock: if not hasattr(cls_1, instance_attr): setattr(cls_1, instance_attr, __origin_new__(cls_1, *args, **kwargs)) return getattr(cls_1, instance_attr) cls.__new__ = __new__# 替换 __init__函数原理同上 init_flag = '_init_flag' __origin_init__ = cls.__init__ @wraps(__origin_init__) def __init__(self, *args, **kwargs): if not hasattr(self, init_flag): with lock: if not hasattr(self, init_flag): __origin_init__(self, *args, **kwargs) setattr(self, init_flag, True) cls.__init__ = __init__ return cls return decorator

使用方法非常简单：

@singleton() class Test: def __init__(self): # do something pass

需要注意的是装饰器要加括号，这是为了给每个类绑定一个线程锁，具体原理与单例模式无关，这里就不赘述了。另外使用了装饰器的类不需要修改 __new__ 函数，和普通的类一样使用就行。关于这个装饰器的具体实现原理我会找时间再写一篇博客。
参考
菜鸟教程-单例模式：https://www.runoob.com/design-pattern/singleton-pattern.html
博客园-听风。-Python中的单例模式的几种实现方式的及优化:https://www.cnblogs.com/huchong/p/8244279.html