你真的了解Python的单例模式吗？

你真的了解Python的单例模式吗?

最近在用Python单例模式的时候遇到一些问题, 还是自己太年轻了, 在这里总结一下我在使用这个设计模式的时候的坑.

前言(单例模式简介)

单例模式提供了这样一个机制，即确保类有且只有一个特定类型的对象，并提供全局访问点。因此，单例模式通常用于下列情形，例如日志记录或数据库操作、打印机后台处理程序，以及其他程序——该程序运行过程中只能生成一个实例，以避免对同一资源产生相互冲突的请求。例如，我们可能希望使用一个数据库对象对数据库进行操作，以维护数据的一致性；或者希望使用一个日志类的对象，将多项服务的日志信息按照顺序转储到一个特定的日志文件中。

简单来说, 单例模式可以总结为下面三个要点:

•确保类有且只有一个对象被创建。•为对象提供一个访问点，以使程序可以全局访问该对象。•控制共享资源的并行访问。

下文中, 我们将会用Python来实现单例模式, 不做特殊说明, 下文中所有的代码均基于Python 3.6.8实现.

经典的单例模式

代码如下所示:

class Singleton:

def __new__(cls, *args, **kwargs): if not hasattr(cls, 'instance'): cls.instance = super(Singleton, cls).__new__(cls) return cls.instance

def test(): s1 = Singleton() s2 = Singleton() print(f"s1: {s1}\ns2: {s2}")

我们来运行代码查看一下运行结果.

可以发现上述代码满足如下两个要求:

•只允许Singleton类生成一个实例。•如果已经有一个实例了，会重复提供同一个对象。

懒汉实例化版单例模式

单例模式的用例之一就是懒汉式实例化。例如，在导入模块的时候，我们可能会无意中创建一个对象，但当时根本用不到它。懒汉式实例化能够确保在实际需要时才创建对象。所以，懒汉式实例化是一种节约资源并仅在需要时才创建它们的方式。下面我们来看一下代码:

class LazySingleton: __instance = None

def __init__(self): if not LazySingleton.__instance: print('Called __init__ method...') else: print("Instance already created @: ", self.get_instance())

@classmethod def get_instance(cls): if not cls.__instance: cls.__instance = LazySingleton() return cls.__instance

def test():

s1 = LazySingleton() print("Created Object", LazySingleton.get_instance()) s2 = LazySingleton()

同样来看一下代码的运行结果,

利用元类实现单例模式

为什么会考虑到这么写, 因为如果我想对某个类实现单例模式, 我要复制上面的一堆代码, 这显现不够Pythonic, 因此考虑一下使用元类来实现. 有人可能发问了, 这为什么不用继承来实现, 写一个基类, 其他子类继承他不就好了吗? 悄悄的说一句, 如果用继承的话是有坑的, 下面首先来看一下继承方法为什么不可以.

来看一个简单的例子, 还是使用前面所说的简单单例.

class Singleton:

def __new__(cls, *args, **kwargs): if not hasattr(cls, 'instance'): cls.instance = super(Singleton, cls).__new__(cls) return cls.instance

class FirstChildSingleton(Singleton): pass

class SecondChildSingleton(Singleton): pass

def test(): s1 = Singleton() s2 = Singleton() print(f"s1: {s1}\ns2: {s2}")

first_child = FirstChildSingleton() second_child = SecondChildSingleton() print(f"first child: {first_child}\nsecond child: {second_child}")

打印一下结果, 可以发现,

这里所有的子类也是同一个对象, 这显然是不行的.

什么是元类

让我们先来了解一下元类。元类是一个类的类，这意味着该类是它的元类的实例。使用元类，程序员有机会从预定义的Python类创建自己类型的类。

在Python中，一切皆对象。如果我们说a=1，则type(a)返回，这意味着a是int类型。但是，type(int)返回，这表明存在一个元类，因为int是type类型的类。

具体有关元类的知识, 在本文中不多介绍了, 不是这一篇文章的重点.

单例实现

首先还是老套路, 先来看一下代码:

class MetaSingleton(type): def __call__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): cls._instance = super(MetaSingleton, cls).__call__(*args, **kwargs) return cls._instance

class FirstChildMetaSingleton(metaclass=MetaSingleton): pass

class SecondChildMetaSingleton(metaclass=MetaSingleton): pass

def test():

s1 = FirstChildMetaSingleton() s2 = SecondChildMetaSingleton() print(f"s1: {s1}\ns2: {s2}")

我们可以发现, 这样的话, 实例化出来的单例就不是同一个了.

线程安全的单例

你以为写个元类, 这样就可以解决一切问题吗? 哈哈, 太天真了, 上述的写法实际上是非线程安全的, 我们来看一个例子.

先来看一下代码,

class SimpleSingleton(metaclass=MetaSingleton): def __init__(self): time.sleep(1)

def create_in_thread(name): s = SimpleSingleton() print(f'{name}: {s}')

def test(): t1 = threading.Thread(target=create_in_thread, args=("first thread",)) t2 = threading.Thread(target=create_in_thread, args=("second thread",))

t1.start() t2.start() t1.join() t2.join()

从上图中可以看到, 这样会创建两个单例, 也就是说这样代码是非线程安全的, 我太难了, 下面来看一个线程安全的单例吧.

class MetaThreadSecuritySingleton(type): _instance_lock = threading.Lock()

def __call__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): with MetaThreadSecuritySingleton._instance_lock: if not hasattr(cls, "_instance"): cls._instance = super(MetaThreadSecuritySingleton, cls).__call__(*args, **kwargs) return cls._instance

class SimpleThreadSecuritySingleton(metaclass=MetaThreadSecuritySingleton): def __init__(self): time.sleep(1)

def create_in_thread(name): s = SimpleThreadSecuritySingleton() print(f'{name}: {s}')

def test(): t1 = threading.Thread(target=create_in_thread, args=("first thread",)) t2 = threading.Thread(target=create_in_thread, args=("second thread",))

t1.start() t2.start() t1.join() t2.join()

最终这个单例终于变得线程安全了, 生活中处处充满着惊喜, 微笑着面对它, 奥利给.