ToB企服应用市场:ToB评测及商务社交产业平台

标题: python中单例模式先容（含线程安全的单例模式） [打印本页]
作者: 大连密封材料    时间: 5 天前
标题: python中单例模式先容（含线程安全的单例模式）
理解单例模式之前，确实必要先掌握 __init__、__new__ 和 __call__ 这三个方法的作用和调用序次。如有必要，读者可跳转下方链接学习：
python中的__init__、__new__、__call__-CSDN博客

正文开始：
在Python中，单例模式（Singleton Pattern）确保一个类只有一个实例，并提供一个全局访问点。
一、利用装饰器实现单例

   原理：通过装饰器控制类的实例化过程，确保仅天生一个实例。
步骤：
  1. 界说一个装饰器函数。
2. 在装饰器中管理实例的创建和返回。
  代码示例：
  1. def singleton_decorator(cls):
  2.     print("装饰器执行（类定义时立即执行）")
  3.     instances = {}
  5.     def get_instance(*args, **kwargs):
  6.         print("调用 get_instance()（实例化时执行）")
  7.         if cls not in instances:        # 单例模式的关键点就在这里
  8.             print("创建新实例")
  9.             instances[cls] = cls(*args, **kwargs)
  10.         return instances[cls]
  12.     return get_instance
  15. @singleton_decorator
  16. class SingletonClass:
  17.     def __init__(self):
  18.         print("调用 __init__()")
  19.         self.data = "Singleton Data"
  22. # 测试
  23. print("开始实例化")
  24. a = SingletonClass()
  25. print("------------")
  26. b = SingletonClass()
  27. print(a is b)  # 输出：True
  30. # 装饰器执行（类定义时立即执行）
  31. # 开始实例化
  32. # 调用 get_instance()（实例化时执行）
  33. # 创建新实例
  34. # 调用 __init__()
  35. # ------------
  36. # 调用 get_instance()（实例化时执行）
  37. # True
复制代码
二、元类实现单例重写__call__

   原理：通过元类的 __call__ 方法控制实例创建流程。
步骤：
  1. 界说一个元类，重写 __call__ 方法。
  2. 在元类中查抄是否已存在实例。
  代码示例：
  1. class SingletonMeta(type):
  2.     _instances = {}
  4.     def __call__(cls, *args, **kwargs):
  5.         print("调用 __call__()")
  6.         if cls not in cls._instances:
  7.             cls._instances[cls] = super().__call__(*args, **kwargs)
  8.         return cls._instances[cls]
  11. class SingletonClass(metaclass=SingletonMeta):
  12.     def __init__(self):
  13.         print("调用 __init__()")
  14.         self.data = "Singleton Data"
  17. # 测试
  18. a = SingletonClass()
  19. b = SingletonClass()
  20. print(a is b)  # 输出：True
  22. # 调用 __call__()
  23. # 调用 __init__()
  24. # 调用 __call__()
  25. # True
复制代码
三、重写 __new__ 

   原理：通过重写类的 __new__ 方法，直接控制实例创建。
步骤：
  1. 在类中界说类变量存储实例。
2.在 __new__ 方法中返回已有实例或创建新实例。
  代码示例：
  1. class SingletonClass:
  2.     _instance = None
  4.     def __new__(cls, *args, **kwargs):
  5.         print("__new__")
  6.         if not cls._instance:
  7.             cls._instance = super().__new__(cls)
  8.         return cls._instance
  10.     def __init__(self):
  11.         print("__init__")
  12.         self.data = "Singleton Data"
  15. # 测试
  16. a = SingletonClass()
  17. b = SingletonClass()
  18. print(a is b)  # 输出：True
  20. # __new__
  21. # __init__
  22. # __new__
  23. # __init__
  24. # True
复制代码
四、线程安全的单例模式

问题：上述方法在并发环境下大概创建多个实例。
解决方案：加锁（如 threading.Lock）确保线程安全。
代码示例（元类 + 线程安全）​：
  1. import threading
  4. class SingletonMeta(type):
  5.     """
  6.     单例模式的元类实现。
  7.     控制类的实例化过程，确保线程安全且唯一实例。
  8.     """
  9.     _instances = {}  # 保存所有单例类的实例（键是类，值是实例）
  10.     _lock = threading.Lock()  # 线程锁
  12.     def __call__(cls, *args, **kwargs):
  13.         # 第一次检查：避免已存在实例时不必要的加锁
  14.         if cls not in cls._instances:
  15.             # 加锁确保线程安全
  16.             with cls._lock:
  17.                 # 第二次检查：防止其他线程已创建实例
  18.                 if cls not in cls._instances:
  19.                     # 创建实例并保存
  20.                     instance = super().__call__(*args, **kwargs)
  21.                     cls._instances[cls] = instance
  22.         # 返回已存在的实例
  23.         return cls._instances[cls]
  26. class Singleton(metaclass=SingletonMeta):
  27.     """
  28.     单例类示例。
  29.     通过元类 SingletonMeta 控制实例唯一性。
  30.     """
  31.     def __init__(self):
  32.         # 初始化代码（只会执行一次）
  33.         self._data = "单例数据"
  34.         print("Singleton 初始化完成")
  37. # 测试多线程环境下的单例行为
  38. def create_singleton():
  39.     obj = Singleton()
  40.     print(id(obj))
  42. if __name__ == "__main__":
  43.     threads = []
  44.     for _ in range(5):
  45.         t = threading.Thread(target=create_singleton)
  46.         threads.append(t)
  47.         t.start()
  49.     for t in threads:
  50.         t.join()
  52. # Singleton 初始化完成
  53. # 1807031580512
  54. # 1807031580512
  55. # 1807031580512
  56. # 1807031580512
  57. # 1807031580512
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4