python 之单例复用

一、单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

注意：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

二、介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

• 1、一个班级只有一个班主任。
• 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
• 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

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

使用场景：

• 要求生产唯一序列号。
• WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
• 配置管理类（配置文件只加载一次）
• 数据库连接池（共享连接资源）
• 日志系统（统一输出控制）
• 缓存管理器
• 操作系统资源管理器（如线程池、任务调度器）

三、python中实现单例模式的5种方法

1、使用模块导入的方式

from p import p1
from p import p1 as p2

print(p1 is p2)

2、使用装饰器

def singleton(cls):
    instance = None

    def _singleton(*args, **kargs):
        nonlocal instance
        if not instance:
            instance = cls(*args, **kargs)
        return instance

    return _singleton


@singleton  # A=singleton(A)
class A():
    def __init__(self, x=0):
        self.x = x


a1 = A(2)  # 其实执行的是 singleton内部的闭包函数 _singleton()
a2 = A(3)

print(a1 is a2)

3、使用类方法

class Singleton(object):
    _instance = None

    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = cls(*args, **kwargs)
        return cls._instance


a1 = Singleton.instance()
a2 = Singleton.instance()

print(a1 is a2)

4、使用 __new__

__new__在__init__先执行

class Singleton(object):
    _instance = None

    def __init__(self):
        pass

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


obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)

#1 类()--->触发类中的__init__--->对象已经创建出来了，不能拦截住，做成单例了

#2 类()--->触发类中的__new__--->真正的创建对象，判断之前有没有创建过，如果创建过，直接返回

#3 元类---》类()--->触发元类的 __call__--->判断之前有没有创建过，如果创建过，直接返回

5、基于metaclass 元类实现

通过元类 产生类 这个对象的 类，称之为元类

# 类中的 __call__ 对象() 会触发

class SingletonType(type):
    _instance = None

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


class Foo(metaclass=SingletonType):
    def __init__(self, name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1 is obj2)

四、单例小案例

1、优化前的代码

MINIO_IP = "node1:19000"

MINIO_CONFIG = {
    'endpoint': MINIO_IP,
    'access_key': "AKI",
    'secret_key': "skY",
    'secure': False
}

def get_minio():
    return Minio(**MINIO_CONFIG)

# 后续多次调用生成一个客户端对象
minio_client = get_minio()

缺点：

每次调用都会创建一个新的 Minio 客户端实例，确实会带来不必要的 资源开销（主要是连接信息、认证、TLS 初始化等），尤其在如下场景中影响更明显：

• 每个 batch 处理文档时都调用 get_minio()；

• 多线程或多进程并发使用；

• MinIO 本身部署在远端、网络有延迟时；

• 高频次归档/删除操作；

2、使用单例模式来缓存 Minio 实例

方式1: 使用全局变量华缓存

_minio_client = None

def get_minio():
    global _minio_client
    if _minio_client is None:
        _minio_client = Minio(**MINIO_CONFIG)
    return _minio_client

方式2: 使用 functools.lru_cache 装饰器（推荐）

多次调用也只初始化一次

from functools import lru_cache

@lru_cache(maxsize=1)
def get_minio():
    return Minio(**MINIO_CONFIG)

什么是 functools.lru_cache

lru_cache 是 Python 的一个 装饰器，用于 缓存函数的返回值，避免重复计算，提升性能。

• LRU = Least Recently Used（最近最少使用）

• 装饰的函数在多次调用相同参数时，会从缓存中取值，而不是重新执行。

from functools import lru_cache

@lru_cache(maxsize=128)  # 最多缓存 128 个不同参数的结果
def fib(n):
    print(f"Calculating fib({n})")
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(10))  # 后续对 fib(10)、fib(9)... 会使用缓存
print(fib(10))
print(fib(20))
print(fib(30))  # 后续对 fib(20)、fib(19)... 会使用缓存

• maxsize: 缓存的最大数量（设为 None 表示无限缓存）这里允许 fib 函数最多记住 128 个不同的 n 值
• typed: 如果为 True，会区分 1 和 1.0 这样的参数类型
• print(fib.cache_info()) 查看缓存命中率
• fib.cache_clear() 清理缓存

Fibonacci 的递归调用是指数级的：

• 不加缓存：每次都重复计算，例如 fib(6) 会被调用 多次

• 加上 @lru_cache 后，所有已算过的 fib(n) 结果会被缓存

这样不仅提高性能，也避免大量无效递归。

方法 3：使用自定义单例类封装（更通用）

class MinioSingleton:
    _instance = None

    @classmethod # 类的方法绑定
    def get_instance(cls):
        if cls._instance is None:
            cls._instance = Minio(**MINIO_CONFIG)
        return cls._instance

# 使用
minio_client = MinioSingleton.get_instance()

补充：

什么是 Pythonic？

Pythonic 是一个常用术语，用来描述：

“用 Python 的方式做事”，即符合 Python 语言哲学、语法习惯和设计风格的代码写法。

# 非 Pythonic
squares = []
for i in range(10):
    squares.append(i * i)

# Pythonic
squares = [i * i for i in range(10)]

方式4：Pythonic + lru_cache 结合案例

from functools import lru_cache
from minio import Minio

@lru_cache(maxsize=1)
def get_minio():
    return Minio("node1:19000", access_key="AK", secret_key="SK", secure=False)

client1 = get_minio()
client2 = get_minio()
print(client1 is client2)  # True ✅，单例行为