四种方法编写 Python 的单例模式

作者: 王炳明 分类: Python 高手进阶 发布时间: 2022-11-20 22:25 热度:248

单例模式一种常见的设计模式,并且也是最基础的设计模式,需要每个开发人员都熟练掌握。

当你希望在整个系统中,某个类只能出现一个实例时,就需要学会使用单例模式。

比较常见的场景是:某个项目的配置信息存放在一个配置文件中,通过一个 Config 的类来读取配置文件的信息。如果在程序运行期间,有很多地方都需要使用配置文件的内容,也就是说,很多地方都需要创建 Config 对象的实例,这就导致系统中存在多个 Config 的实例对象,而这样会严重浪费内存资源,尤其是在配置文件内容很多的情况下。事实上,类似 Config 这样的类,我们希望在程序运行期间只存在一个实例对象。

在 Python 中,可以用多种方法实现单例模式,常见的有:

  • 通过使用模块
  • 通过装饰器
  • 通过__new__方法
  • 通过元类

下面就详细说明以下这几种实现方法:

1. 通过使用模块

在Python中,Python 的模块就是天然的单例模式。

因为模块在第一次导入时,会生成 .pyc 文件,当第二次导入时,就会直接加载 .pyc 文件,而不会再次执行模块代码。因此,我们只需把相关的函数和数据定义在一个模块中,就可以获得一个单例对象了。

看如下示例:

# 例如在config.py文件中定义Config类和实例
class Config:
    LOG_LEVEL = 'INFO'
    ...

config = Config()


# 然后在其他文件中,通过import导入此实例
from config import config

print(config.LOG_LEVEL)
# 输出结果:INFO

如上所示,通过在文件中先生成一个类实例,然后在别的文件中直接导入这个类实例,就实现了单例模式。

2. 通过装饰器

另外一种典型的用法是使用类装饰器,由于逻辑比较易懂,被广泛被开发人员使用。

如下是一个例子,在每次对 Config 实例化的时候,都会进入 Singleton 类装饰器,该装饰器维护一个 dict,key 为 cls,value 为 instance,每次实例化都检查该 cls 是否已经在 dict 中存在,若存在则直接将之前实例化的对象返回,如此来保证单例。

from functools import wraps


def Singleton(cls):
    instance = {}

    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instance:
            instance[cls] = cls(*args, **kwargs)
        return instance[cls]

    return wrapper


@Singleton
class Config(object):
    pass


cfg1 = Config()
cfg2 = Config()

print(cfg1 == cfg2)

运行后,输出结果 True

不过,这种方法虽然逻辑非常清晰易懂,但却有一个非常大的问题:经过 Singleton 装饰的后,其返回的是函数,因为无法被继承。

装饰器由于本身机制的限制,在实例单例的同时也带来了一定的 “副作用”。

仔细一想,用装饰器实现单例的思路,不就是拦截实例对象的创建,来保证类只有唯一的实例嘛!

那我们只要换种方法,来拦截实例对象的创建不就行了。

通常的方法,有两种:

  • __new__ 方法
  • 元类

3. 通过__new__方法

先说一下 __new__ 方法,它是 Python 中的魔法方法之一。

很多人可能对他不是很熟悉,不过完全没有关系,你只要知道,当你在实例化的时候,是先执行类的 __new__ 方法,再执行类的 __init__ 即可。

因此,我们可以在 __new__ 上做一些事情,使得类的实例只能存在一个。

如下是一个示例,在第一次实例的时候,会在 cls 上添加一个属性 _instance 来保存第一个实例,后面再实例化时,就会返回第一次创建的时候,

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


cfg1 = Config()
cfg2 = Config()

print(cfg1 == cfg2)

运行后,输出结果 True

细心的朋友,想必已经发现,如果有其他类继承了 Config 这个类,那么 _instance 也同样会被子类继承过去,这会导致只要 Config 及其子类只能有一个实例,只要 Config 实例过了,其子类就不能再实例化了,但这显然不是我们所期望的。

有的朋友,可能会想到用双下划线的 __instance,这样就不会被继承了。

很遗憾的是,双下划线的属性,虽然不会被继承,但却有一个问题,就是属性名会被 Python 修改掉,变成 _Config__instance,这样一样,我们在编写 __new__ 时就无法使用 hasattr 来判断。

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


cfg1 = Config()
print(hasattr(Config, "__instance"))          # 输出:False
print(hasattr(Config, "_Config__instance"))   # 输出:True

最好的做法是:在所有的子类将 _instance 重置为 None,并且重写 __new__ 方法,最重要的是不要去调用 supper.__new__()

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


class ConfigExt(Config):
    _instance = None

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


cfg1 = Config()
cfg2 = ConfigExt()
cfg3 = ConfigExt()

print(cfg1 == cfg2)  # False
print(cfg2 == cfg3)  # True

可以看到,通过修改 __new__ 方法,已经可以解决装饰器不能被继承的问题,但在有可能被继承的类里,却存在安全隐患。

4. 通过 metaclass

metaclass 是什么呢? 用一句话说明

  • 类,是用来创建实例对象的「模板」。

  • 而元类,是创建类的「模板」。

因此我们可以通过修改元类,来使得创建此类时,就直接是一个单例类。

学习元类的作用过程,可以用普通类来做对比学习:

  • 在创建一个实例时,会走类的 __new__ 方法

  • 同样地逻辑,在创建一个普通类时,也会走元类的 __new__

与此同时:

  • 在类里实现了 __call__ 可以让这个类的实例,变成可调用对象
  • 对普通类进行实例化时,实际是对一个元类的实例(也就是普通类)进行直接调用,因此会走元类的 __call__ 方法

如下是一个示例,可以发现,父类和子类都可以完美实现单例,而不需要有额外的约定,也不需要团队里的人有统一的技术积累,就像平时一样,不会有任何突兀的感觉。

class Singleton(type):
    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        super().__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance


class Config(metaclass=Singleton):
    pass


class ConfigExt(Config):
    pass


cfg1 = Config()
cfg2 = Config()
cfg3 = ConfigExt()
cfg4 = ConfigExt()

print(cfg1 == cfg2)  # True
print(cfg2 == cfg3)  # False
print(cfg3 == cfg4)  # True

另外,该方法在多线程场景下并发创建实例对象时,由于初始化时,是需要一点时间,那么就会导致数据不同步的问题,导致出现多个实例。

为了方便复现,我在 __call__ 里加了 time.sleep(1) 来实现延长实例化的时间

import time
import threading

class Singleton(type):
    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        super().__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        if not cls.__instance:
            time.sleep(1)
            cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance


class Config(metaclass=Singleton):
    pass


def task():
    cfg = Config()
    print(id(cfg))


for i in range(10):
    t = threading.Thread(target=task)
    t.start()

运行结果如下,说明单例模式出现了问题

4336068992
4373051424
4335324896
4336069088
4335324848
4336069088
4335324896
4336069088
4335324848
4336069088

但这个问题可以通过线程锁来解决,先定义一个装饰器 synchronized ,然后在元类里的 __call__ 加上这个装饰器。

import time
import threading


def synchronized(func):
    func.__lock__ = threading.Lock()

    def lock_func(*args, **kwargs):
        with func.__lock__:
            return func(*args, **kwargs)

    return lock_func


class Singleton(type):
    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        super().__init__(*args, **kwargs)

    @synchronized
    def __call__(cls, *args, **kwargs):
        if not cls.__instance:
            time.sleep(1)
            cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance


class Config(metaclass=Singleton):
    pass


def task():
    cfg = Config()
    print(id(cfg))


for i in range(10):
    t = threading.Thread(target=task)
    t.start()

运行的结果就正常了

4381387136
4381387136
4381387136
4381387136
4381387136
4381387136
4381387136
4381387136
4381387136
4381387136

5. 总结一下

在 Python 中有很多种方法实现单例的效果,但不同的方法,却有不同的局限性:

  • 使用模块:最简单直接且安全,推荐使用
  • 使用装饰器:不能被继承,不推荐使用
  • 使用 new 方法:需要开发成员有共同的技术背景,对Python有足够的认识,不然代码会有BUG。
  • 使用 metaclass:完美的单例实践,也推荐使用

文章有帮助,请作者喝杯咖啡?

发表评论