Python单例模式（三种实现方式：覆写new方法、使用装饰器、使用元类）（单例模式之线程安全）（单例的懒汉模式与饿汉模式）

🕗 发布于 2024-10-13 10:32 python 单例模式安全

文章目录

Python单例模式详解
单例模式之线程安全
单例的懒汉模式与饿汉模式
示例
- 配置文件单例模式（采用饿汉模式，无需考虑线程安全问题）
- - `__init__.py`
  - `sensor_cfg.py`

Python单例模式详解

介绍

单例模式是一种常用的软件设计模式，目的是确保一个类只有一个实例，并提供一个访问该实例的全局访问点。在多线程环境中，单例模式能够避免对共享资源的多重占用，是构建资源管理器、工厂类等对象时的首选模式。

单例模式的用途

单例模式主要用于以下场景：

- 当类的构造函数被标记为私有时，保证无法在类外部实例化。

- 当系统中的某个类只需要一个全局实例时，例如配置管理器、线程池等。

- 资源共享，例如全局缓存、全局状态管理等。

实现单例模式

Python中实现单例模式有多种方法，以下分别展示几种典型的实现方式。

使用模块

由于Python的模块在第一次导入时会被初始化，之后再次导入时会直接使用已经加载的模块对象，所以可以通过简单地将所需要的类的实例化放在一个模块中来实现单例模式。

# singleton_module.py
class Singleton:
    def __init__(self):
        self.value = "Singleton Instance"

singleton_instance = Singleton()

使用时直接从模块中导入这个实例：

from singleton_module import singleton_instance

# 这里的singleton_instance已经是一个全局的单例
print(singleton_instance.value)

使用`new`方法

在Python中，__new__方法负责实例化对象。可以通过覆写这个方法来控制对象的创建过程，从而实现单例模式。

class Singleton:
    _instance = None

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

    def __init__(self):
        self.value = "Singleton Instance"

测试单例：

a = Singleton()
b = Singleton()
print(a == b)  # 输出 True
print(a.value)  # 输出 Singleton Instance

使用装饰器

可以创建一个装饰器来封装单例的创建逻辑，这使得单例模式的使用更加灵活和简单。

def singleton(cls):
    instances = {}

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

@singleton
class Singleton:
    def __init__(self):
        self.value = "Singleton Instance Decorated"

测试装饰器实现的单例：

a = Singleton()
b = Singleton()
print(a == b)  # 输出 True
print(a.value)  # 输出 Singleton Instance Decorated

使用元类

元类是创建类的类，可以通过自定义元类来控制类的创建过程。下面是使用元类实现单例模式的例子：

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        self.value = "Singleton Instance with Meta"

测试元类实现的单例：

a = Singleton()
b = Singleton()
print(a == b)  # 输出 True
print(a.value)  # 输出 Singleton Instance with Meta

单例模式的优缺点

优点

确保一个类只有一个实例，并提供一个全局访问点。
可以延迟初始化，即在真正需要使用时才创建实例。

缺点

如果不需要单例，后期很难适应变化。
可能会导致代码难以测试。
在多线程环境中，需要特别注意实现方式，防止多线程同时创建多个实例。

总结

单例模式是一个非常有用的模式，在很多需要控制资源访问或者状态共享的场景下非常有用。Python提供了多种方式来灵活实现单例模式，可以根据具体需要选择合适的实现方式。

单例模式之线程安全

在多线程环境中，确保单例模式的线程安全是非常重要的。在Python等语言中，如果不适当地实现单例模式，确实有可能在多线程情况下创建多个实例，因此在某些实现方法中需要加锁来确保只创建一个实例。

线程安全的单例实现

以下是几种可以确保线程安全的单例实现方法：

使用线程锁

可以在创建实例的过程中使用线程锁来确保在任何时刻只有一个线程可以执行实例创建代码。

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()  # 创建一个锁

    def __new__(cls, *args, **kwargs):
        with cls._lock:  # 锁定代码块
            if not cls._instance:
                cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

这种方法利用了锁，保证了即使在多线程环境中也只能创建一个实例。

使用`new`方法和双重检查锁定（Double-Checked Locking）

这是一个优化的线程安全单例实现，它在实例已经创建后避免了锁的开销。

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            with cls._lock:
                if not cls._instance:
                    cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

这里使用了两层检查：外层检查避免每次都需要锁定，只有当实例尚未创建时才进行锁定和内层检查。

使用模块级别的单例

由于Python的模块在第一次导入时只会被加载一次，利用这一特性可以创建一个天然的线程安全的单例模式，如前文中模块实现的例子。这种方法在Python中是线程安全的，因为模块加载本身在Python中是线程安全的。

使用元类和线程锁

元类也可以结合线程锁来实现线程安全的单例模式。

class SingletonMeta(type):
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]

这种方法结合了元类的强大功能和线程锁的安全性，保证了即使在多线程环境中也只会创建一个实例。

总结

在多线程环境中实现单例模式时，确保线程安全是非常重要的。Python提供了多种方法来实现线程安全的单例，包括使用锁、双重检查锁定和利用模块加载的天然线程安全特性。选择合适的实现方式可以根据具体应用场景和性能要求来决定。

单例的懒汉模式与饿汉模式

在单例模式的实现中，"懒汉模式"和"饿汉模式"是两种常见的初始化策略，各有特点和适用场景。

饿汉模式

饿汉模式指的是在类加载时就立即初始化单例对象，无论之后会不会用到这个实例。这种方式的主要优点是实现简单，无需考虑多线程问题，实例在应用启动时就已经存在了。

饿汉模式的实现

在Python中，饿汉模式可以通过在模块级别直接实例化单例来实现：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 在模块加载时就创建一个实例
singleton_instance = Singleton()

在这种方式中，singleton_instance将在模块首次加载时创建，确保了单例对象的即时可用性。

懒汉模式

懒汉模式指的是类在第一次被使用时才创建实例，而不是在应用启动时。这种方式的优点是节约资源，实例只在需要时才会被创建。

懒汉模式的实现

懒汉模式通常需要考虑线程安全问题，特别是在多线程环境中需要确保只创建一个实例。以下是一个线程安全的懒汉式单例实现：

import threading

class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

这里使用了双重检查锁定来确保只有一个实例被创建，同时减少了锁的开销。

懒汉模式与饿汉模式的比较

初始化时机：饿汉模式在类加载时就完成实例的初始化，而懒汉模式在类的实例首次被请求时才初始化。
资源利用：懒汉模式在不需要实例时不会初始化，从而节约资源；饿汉模式可能会导致资源的早期占用。
性能考虑：饿汉模式无需考虑多线程同步问题，因此在性能上可能稍优；懒汉模式则需要通过同步机制保证线程安全，可能会稍微影响性能。
实现复杂度：懒汉模式在实现时需要考虑线程安全问题，代码相对复杂；饿汉模式实现简单。

选择策略

选择使用懒汉模式还是饿汉模式，主要依赖于具体的应用场景和需求：

如果确保初始化速度并且对启动性能不敏感，可以使用饿汉模式。
如果关注资源利用和延迟加载，懒汉模式可能是更好的选择。

总之，合理的选择单例的实现方式可以帮助更好地适应应用的需求，提高程序的效率和性能。

示例

配置文件单例模式（采用饿汉模式，无需考虑线程安全问题）

`init.py`

from .sensor_cfg import SensorConfig
from .sensor_cfg import Device, DeviceType, SensorConfigData

`sensor_cfg.py`

# sensor_cfg.py

import json
from dataclasses import dataclass
from typing import List, Dict, Optional, Set


CONFIG_PATH = 'config/sensor.json'


@dataclass
class Device:
    address: int
    type: int
    location: str


@dataclass
class DeviceType:
    typeId: int
    description: str


@dataclass
class SensorConfigData:
    modbusRtuDevices: List[Device]
    deviceDefinition: List[DeviceType]


class SensorConfig:
    """
    单例类用于管理传感器配置。

    该类从一个JSON文件中读取并验证传感器配置，
    确保在应用程序的生命周期中只加载一次。
    """
    # 类属性
    _instance = None  # 单例模式保证类只有一个实例

    def __new__(cls) -> 'SensorConfig':
        # 如果实例不存在，创建新的实例
        if cls._instance is None:
            cls._instance = super(SensorConfig, cls).__new__(cls)
        return cls._instance

    def __init__(self) -> None:
        if not hasattr(self, 'initialized'):  # 保证初始化代码只执行一次
            self.data: Optional[SensorConfigData] = None
            self.config_path: str = CONFIG_PATH
            self.load_config()
            self.initialized: bool = True  # 标记实例已被初始化

    @classmethod
    def get_instance(cls) -> 'SensorConfig':
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance

    def load_config(self) -> None:
        """
        从指定的config_path加载配置文件。
        如果文件未找到或JSON无效则抛出错误。
        """
        try:
            with open(self.config_path, 'r', encoding='utf-8') as file:
                # 加载JSON数据
                self.config = json.load(file)

            # Convert loaded JSON to dataclass instances
            modbusRtuDevices = [Device(**device)
                                for device in self.config['modbusRtuDevices']]
            deviceDefinition = [DeviceType(**type_info)
                                for type_info in self.config['deviceDefinition']]
            self.data = SensorConfigData(
                modbusRtuDevices=modbusRtuDevices,
                deviceDefinition=deviceDefinition
            )

            # 校验加载的配置数据
            self.validate_config()
        except FileNotFoundError as exc:
            raise FileNotFoundError(
                f'配置文件 [{self.config_path}] 未找到，请检查路径。') from exc
        except json.JSONDecodeError as exc:
            raise ValueError("配置文件中的JSON格式无效。") from exc

    def validate_config(self) -> None:
        """
        验证加载的配置，确保所有设备类型都已定义，地址在有效范围内。
        还会检查是否有重复的设备id和地址。

        # sensor.json 示例
        {
            "modbusRtuDevices": [
                {
                    "address": 1,
                    "type": 1,
                    "location": "仓库"
                },
                {
                    "address": 2,
                    "type": 2,
                    "location": "蒸馏室"
                },
                {
                    "address": 3,
                    "type": 3,
                    "location": "办公室1"
                },
                {
                    "address": 4,
                    "type": 3,
                    "location": "办公室2"
                }
            ],
            "deviceDefinition": [
                {
                    "typeId": 1,
                    "description": "甲烷传感器"
                },
                {
                    "typeId": 2,
                    "description": "一氧化碳传感器"
                },
                {
                    "typeId": 3,
                    "description": "温湿度传感器"
                }
            ]
        }
        """

        if self.data is None:
            raise ValueError("配置数据未加载，无法验证配置。")

        # 用于检查id和地址是否重复
        device_type_ids: Set[int] = set()
        used_addresses: Set[int] = set()

        # 首先验证设备定义中的ID是否重复
        for device_type in self.data.deviceDefinition:
            type_id = device_type.typeId
            if type_id in device_type_ids:
                raise ValueError(f"在deviceDefinition中发现重复的typeId：{type_id}")
            device_type_ids.add(type_id)

        # 验证每个设备的配置
        for device in self.data.modbusRtuDevices:
            address = device.address
            device_type = device.type

            # 校验地址是否为有效的Modbus地址
            if not (1 <= address <= 247):
                raise ValueError(f"Modbus地址 {address} 无效。必须在1到247之间。")

            # 检查地址是否重复
            if address in used_addresses:
                raise ValueError(f"在ModbusRTU设备中发现重复的地址：{address}")
            used_addresses.add(address)

            # 校验设备类型是否已在deviceDefinition中定义
            if device_type not in device_type_ids:
                raise ValueError(f"设备类型 {device_type} 在地址 {address} 上未定义。")

    @property
    def devices(self) -> List[Device]:
        """
        返回设备配置信息。
        """
        return self.data.modbusRtuDevices if self.data else []

    @property
    def device_types(self) -> Dict[int, str]:
        """
        返回设备类型映射表。
        """
        return {dt.typeId: dt.description for dt in self.data.deviceDefinition} if self.data else {}


# 饿汉模式：模块加载时就创建实例
SensorConfig()


# 使用示例
if __name__ == "__main__":
    sensor_config = SensorConfig.get_instance()  # 获取单例实例
    print(sensor_config.devices)  # 输出所有设备的详细信息
    print(sensor_config.device_types)  # 输出所有设备类型的映射表

原文地址：https://blog.csdn.net/Dontla/article/details/142868622

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：智能生成ppt软件哪个好？如何高效生成ppt？
下一篇：2024年危险化学品经营单位安全管理人员证考试题库及危险化学品经营单位安全管理人员试题解析

人人都是程序员—AI大模型的应用远比你想像的要简单
2022年底OpenAI发布了语言大模型chatgpt3.5，它能像人一样跟我们聊天，从此AI市场着了大火，国内外各个顶级科技公司纷纷跟进，出现了一大批的AI大模型，比如文心一言（百度）、Gemini
阅读更多2024-10-18
vue项目配置配置代理解决请求接口跨域问题
以上的配置生效都是为了本地开发连接测试的接口，生产环境不存在这种问题。服务器可以直接转发配置即可完成跨域的问题。使用vite搭建的vue项目配置方法。使用webpace构建的vue项目。
阅读更多2024-10-18
Ubuntu安装运行 xx.AppImage 文件
（以LM_Studio-0.3.4.AppImage为例）
阅读更多2024-10-18
“区块链技术引领支付安全新纪元：积分系统的革新与未来展望“
这一系统从根本上改变了传统积分的发行、流转与管理方式，借助不可更改的数据记录和智能合约的自动化执行，保证了积分的透明度、安全性及高效运行。传统的支付架构在应对海量交易时，存在审核流程复杂、合规费用高昂
阅读更多2024-10-18
（JAVA）有向图与拓扑排序的实现原理与基本实现
有向图是一副具有方向性的图，是由一组顶点和一组有方向的边组成的，每条方向的边都连着一对有序的灌顶啊。
阅读更多2024-10-18
Nest.js 实战 (十五)：前后端分离项目部署的最佳实践
这篇文章介绍了如何使用现代前端框架Vue3和后端Node.js框架Nest.js实现的前后端分离架构的应用，并将其部署到生产环境。文章涵盖了准备阶段，包括云服务器的设置、1Panel面板的安装、数据库
阅读更多2024-10-18
Vert.x，Web - Web
这是学习案例的前端部分。前端使用layui UI框架，使用其layui table组件实现员工信息增删改操作。Http Server前端也设计成一个Verticle，启动一个Http server，监
阅读更多2024-10-18
mysql基础知识点一
mysql基础知识点一。安装MYSQL，我们就直接安装，不使用修改my.ini文件那种方式然后安装SQLyog，SQLyog不能直接安装在系统盘上，要不然删除的时候可能会把系统盘删除掉，要安装旗舰版，
阅读更多2024-10-18
【C语言】一维数组的定义与初始化
定义时根据数据类型，使用基本数据类型进行定义。注意数组的下标从0开始，使用的时候只能访问合法的下标。比如定义数组大小为10，那么就不能访问数组中的第15个数据。初始化包括全部初始化，直接把所有数据给到
阅读更多2024-10-18
MongoDB 的安装详情
MongoDB 的安装详情
阅读更多2024-10-18

Python单例模式（三种实现方式：覆写__new__方法、使用装饰器、使用元类）（单例模式之线程安全）（单例的懒汉模式与饿汉模式）