Python 实现单例模式

Python碎片公众号

发布于 2021-02-26 15:20:33

1.8K0

发布于 2021-02-26 15:20:33

文章被收录于专栏：Python碎片公众号的专栏

单例模式是一种软件设计模式。

在面向对象编程中，通过单例模式只能创建一个类实例，也就是一个类永远只有一个实例对象。

在工作中，为了确保某一个类只会创建出一个实例，就需要使用单例模式。

在 Python 中，实现单例的方法有很多。

一、通过装饰器的方式实现单例

def singleton_func(cls):
    instances = {}
 
    def _singleton(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
 
    return _singleton
 
 
@singleton_func
class Phone(object):
 
    def phone_id(self):
        return id(self)
 
 
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())

运行结果：

44502488
44502488

通过装饰器来实现单例，直接用装饰器装饰类，实例化两遍类对象，对象的id是相等的，说明并没有两个实例对象，只是两个变量指向一个单例。如果注释掉上面的装饰器，则创建的是两个不同的实例（id不相等）。

在 Python 中，一切皆对象，所以字典中的数据也是一个个的对象。

在装饰器的内函数中，判断字典是否已经有键值对。如果没有，则添加一个类和类实例的键值对，如果有，则不添加。最后返回字典中的类实例，可以保证每次返回的都是同一个实例。

要使用这个单例装饰器，只要将其装饰到需要实现单例的类上即可。

在单例的多种实现方式中，个人最推荐这种方式，因为装饰器的使用方式即方便又优雅。我们可以将以上装饰器写在一个py文件中，所有需要使用单例的地方，都可以使用，步骤就两个，导入，装饰，如果不需要单例了，注释掉装饰器即可。

装饰器参考：

Python装饰器的实现和万能装饰器

二、使用实例化方式实现单例

class SingletonInstance(object):
 
    def __call__(self, *args, **kwargs):
        return self
 
 
SingletonInstance = SingletonInstance()
s1 = SingletonInstance()
s2 = SingletonInstance()
print(id(s1))
print(id(s2))

运行结果：

51186264
51186264

在类中，先重写类的 __call__ 方法，在 __call__ 方法中返回自己。先实例化一个类的对象，后面所有需要使用这个类的地方，都调用这个实例对象。这样，每次调用的都是同一个实例，所以也能实现单例。

其实 Python 中的模块默认是单例模式的，在其他py文件中导入这个实例，然后使用，也是满足单例模式的。

三、使用类装饰器实现单例

class SingletonDecorator(object):
    _instance = None
 
    def __init__(self, cls):
        self._cls = cls
 
    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = self._cls(*args, **kwargs)
        return self._instance
 
 
@SingletonDecorator
class Phone(object):
 
    def phone_id(self):
        return id(self)
 
 
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())

运行结果：

47898464
47898464

使用装饰器实现单例，因为装饰器除了可以使用闭包实现，还可以使用类实现，所以也可以使用类装饰器来实现单例。

通过重写类的 __call__ 方法实现类装饰器，在 __call__ 方法中判断当前是否有类实例，没有才会创建，从而实现单例。

四、重写类的 __new__ 方法实现单例

class SingletonClass(object):
    _instance = None
 
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(SingletonClass, cls).__new__(cls)
        return cls._instance
 
    _is_init = False
 
    def __init__(self):
        if self._is_init is False:
            print('-*-')
            self._is_init = True
 
 
s1 = SingletonClass()
s2 = SingletonClass()
print(id(s1))
print(id(s2))

运行结果：

-*-
57946912
57946912

在 Python 类中，每次实例化一个类对象时，都会自动先执行 __new__ 方法和 __init__ 方法。__new__ 方法先在内存中为实例对象申请空间，然后 __init__ 方法初始化实例对象。

通过重写 __new__ 方法，如果这个类没有实例对象，则执行 __new__ 方法，有则返回已有的实例，这样就实现了单例。

但是，因为 __init__ 方法是在 __new__ 执行完成后自动执行的，每次实例类的对象时都会执行 __init__ 方法，所以也要对 __init__ 方法进行重写，只有第一次实例化类对象时才执行初始化操作。如果上面代码中不重写 __init__ 方法，则会执行两遍__init__ 方法。

五、通过元类实现单例

class SingletonMeta(type, object):
 
    def __init__(self, *args, **kwargs):
        self._instance = None
        super(SingletonMeta, self).__init__(*args, **kwargs)
 
    # _instance = None
 
    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super(SingletonMeta, self).__call__(*args, **kwargs)
        return self._instance
 
 
class Phone(object, metaclass=SingletonMeta):
 
    def phone_id(self):
        return id(self)
 
 
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())

运行结果：