一、理解单例模式

1.1 单例模式是什么？

单例模式是一种设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。这在需要共享资源或限制某些资源的访问时非常有用。

1.2 单例模式的优点

• 全局访问点：提供了单个访问点来访问类唯一的实例。
• 资源共享：允许所有用户共享相同的数据或资源。
• 限制访问：确保只能创建类的唯一实例，防止创建多个对象。

1.3 单例模式的应用场景

• 数据库连接
• 配置设置
• 日志记录系统
• 缓存服务

二、Python 中的单例模式实现

2.1 使用模块级别的变量

 singleton.py
class Singleton:
    def __init__(self):
        self.value = None

    def set_value(self, value):
        self.value = value

    def get_value(self):
        return self.value

singleton_instance = Singleton()
  

2.2 使用装饰器

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 = None

    def set_value(self, value):
        self.value = value

    def get_value(self):
return self.value
  

2.3 使用元类

class SingletonMeta(type):
    _instances = {}

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

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        self.value = None

    def set_value(self, value):
        self.value = value

    def get_value(self):
        return self.value
  

深入解读单例设计模式：懒汉与饿汉的奥秘

单例设计模式确保一个类仅有一个实例，并提供一个全局访问点。 它避免了不必要的对象创建与销毁，提高了程序的性能和数据一致性。 本文将深入探讨单例设计模式的懒汉与饿汉写法，帮助读者更好地理解这一模式的奥秘。 🔒私有构造器和静态成员单例设计模式的关键在于私有构造器和静态成员。 将构造器私有化，确保外部无法随意创建对象。 静态成员在类加载时仅加载一次，确保类的唯一性。 🐔饿汉模式饿汉模式在类加载时就创建了对象，确保了对象的唯一性。 但它可能会导致不必要的资源浪费，因此需要谨慎使用。 🌞懒汉模式懒汉模式延迟创建对象，避免了不必要的资源浪费。 但在高并发场景下，可能会导致多个对象产生。 为解决这一问题，我们引入同步机制，确保线程安全。 🚀同步块的优化方案同步会带来性能损耗，因此我们需要优化同步块。 在同步块中，我们检查对象是否为空，若为空则创建新实例，从而确保对象的唯一性并提高性能。

Python如何实现单例模式

有些时候你的项目中难免需要一些全局唯一的对象,这些对象大多是一些工具性的东西,在Python中实现单例模式并不是什么难事。 以下总结几种方法:使用类装饰器使用装饰器实现单例类的时候,类本身并不知道自己是单例的,所以写代码的人可以不care这个,只要正常写自己的类的实现就可以,类的单例有装饰器保证。 def singleton(cls):instances = {}def _wrapper(*args, **kwargs):if cls not in instances:instances[cls] = cls(*args, **kwargs)return instances[cls]return _wrapper你会发现singleton装饰器内部使用了一个dict。 当然你也可以用其他的方式,不过以下的实现是错误的:def singleton(cls):_instance = None #外部作用域的引用对于嵌套的内部作用域是只读的def _wrapper(*args, **kwargs):if _instance is None: #解释器会抛出UnboundLocalError: before assignment_instance = cls(*args, **kwargs) #赋值行为使解释器将_instance看作局部变量return _instancereturn _wrapper使用元类(__metaclass__)和可调用对象(__call__)Python的对象系统中一些皆对象,类也不例外,可以称之为”类型对象”,比较绕,但仔细思考也不难:类本身也是一种对象,只不过这种对象很特殊,它表示某一种类型。 是对象,那必然是实例化来的,那么谁实例化后是这种类型对象呢?也就是元类。 Python中,class关键字表示定义一个类对象,此时解释器会按一定规则寻找__metaclass__,如果找到了,就调用对应的元类实现来实例化该类对象;没找到,就会调用type元类来实例化该类对象。 __call__是Python的魔术方法,Python的面向对象是”Duck type”的,意味着对象的行为可以通过实现协议来实现,可以看作是一种特殊的接口形式。 某个类实现了__call__方法意味着该类的对象是可调用的,可以想像函数调用的样子。 再考虑一下foo=Foo()这种实例化的形式,是不是很像啊。 结合元类的概念,可以看出,Foo类是单例的,则在调用Foo()的时候每次都返回了同样的对象。 而Foo作为一个类对象是单例的,意味着它的类(即生成它的元类)是实现了__call__方法的。 所以可以如下实现:class Singleton(type):def __init__(cls, name, bases, attrs):super(Singleton, cls).__init__(name, bases, attrs)cls._instance = Nonedef __call__(cls, *args, **kwargs):if cls._instance is None# 以下不要使用cls._instance = cls(*args, **kwargs), 防止死循环,# cls的调用行为已经被当前__call__协议拦截了# 使用super(Singleton, cls).__call__来生成cls的实例cls._instance = super(Singleton, cls).__call__(*args, **kwargs)return cls._instanceclass Foo(object): #单例类__metaclass__ = Singleton>>>a = Foo()>>>b = Foo()>>>a is b>>>True>>>a.x = 1>>>b.x>>>1使用__new____init__不是Python对象的构造方法,__init__只负责初始化实例对象,在调用__init__方法之前,会首先调用__new__方法生成对象,可以认为__new__方法充当了构造方法的角色。 所以可以在__new__中加以控制,使得某个类只生成唯一对象。 具体实现时可以实现一个父类,重载__new__方法,单例类只需要继承这个父类就好。 class Singleton(object):def __new__(cls, *args, **kwargs):if not hasattr(cls, _instance):cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)return cls._instanceclass Foo(Singleton): #单例类a = 1