Python实现单例模式

一、介绍

单例模式是一种常见的设计模式，它保证一个类只能被实例化一次，并提供了一个全局访问点来获取这个唯一的实例。在Python中，可以通过使用装饰器、元类或模块等方式实现单例模式。

二、Python实现单例模式的6种方法

1、使用模块实现单例

class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()

from mysingleton import singleton
a = singleton
b = singleton
print(id(a))
print(id(b))

  

2、通过装饰器实现单例

def singleeton_func(cls):
    instance={}
    def _singleton(*args, **kwargs):
        if cls not in instance:
            instance[cls] = cls(*args, **kwargs)
        return instance[cls]
    return _singleton

@singleeton_func
class Phone(object):
    def phone_id(self):
        return id(self)

if __name__ == '__main__':
    p1 = Phone()
    p2 = Phone()
    print(p1.phone_id())
    print(p2.phone_id())

在装饰器的内函数中，判断字典是否已经有键值对。如果没有，则添加一个类和类实例的键值对，如果有，则不添加。最后返回字典中的类实例，可以保证每次返回的都是同一个实例。要使用这个单例装饰器，只要将其装饰到需要实现单例的类上即可。

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

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

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

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

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)

if __name__ == '__main__':
    p1 = Phone()
    p2 = Phone()
    print(p1.phone_id())
    print(p2.phone_id())

_var：命名约定，仅供内部使用。通常不会由Python解释器强制执行。（私有变量）
var_：按约定使用以避免与Python关键字的命名冲突。
__var：当在类上下文中使用时，触发”名称修饰“。由Python解释器强制执行。
__var__：表示Python语言定义的特殊方法。避免在你自己的属性中使用这种命名方案。

使用装饰器实现单例，因为装饰器除了可以使用闭包实现，还可以使用类实现，所以也可以使用类装饰器来实现单例。通过重写类的 __call__ 方法实现类装饰器，在 __call__ 方法中判断当前是否有类实例，没有才会创建，从而实现单例。

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

python中的super()详解参考python中的super调用父类方法

class SingletonClass(object):
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            # cls._instance = super(SingletonClass, cls).__new__(cls)  # python2.x中，super()函数的使用语法格式
            cls._instance = super().__new__(cls)  # python3.x中，super()函数的使用语法格式
        return cls._instance

    _is_init = False
    def __init__(self):
        if self._is_init is False:
            print('-*-')
            self._is_init = True

if __name__ == '__main__':
    s1 = SingletonClass()
    s2 = SingletonClass()
    print(id(s1))
    print(id(s2))

  

 在Python类中，每次实例化一个类对象时，都会自动先执行__new__方法和__init__方法。

__new__方法先在内存中为实例对象申请空间，然后__init__方法初始化实例对象。因为__init__方法是在new执行完成后自动执行的，每次实例类的对象时都会执行__init__方法，所以也要对__init__方法进行重写，只有第一次实例化类对象时才执行初始化操作。

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

6、通过元类（metaclass）实现单例

元类详解参考Python中的元类

class SingletonMeta(type, object):
    def __init__(self, *args, **kwargs):
        self._instance = None
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super().__call__(*args, **kwargs)
        return self._instance

class Phone(object, metaclass=SingletonMeta):
    def phone_id(self):
        return id(self)

if __name__ == '__main__':
    p1 = Phone()
    p2 = Phone()
    print(p1.phone_id())
    print(p2.phone_id())

上述代码中，我们定义了一个名为SingletonMeta的元类。在元类的__call__方法中，我们首先判断该类是否已经存在于instances字典中，如果不存在，则创建一个新的实例并将其添加到instances字典中，否则返回已有的实例。 

 在python中，元类是创建类的类，是创建类的工厂，所有类的元类都是type类，所有类都是type类的实例对象。
 如果自定义一个元类，在元类中重写__call__方法，判断当前是否有实例，没有实例才创建，有则不创建。对需要实现单例的类，指定类的元类是我们自定义的元类，从而实现单例。（不推荐使用此方法）

三、单例模式应用场景

单例模式适用于需要确保一个类只有一个实例对象，并且该对象需要被全局访问的情况。
（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如日志文件、应用配置。
（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

实例--单例模式控制数据库连接池对象：

 假设我们正在开发一个多线程的应用程序，其中包含一个数据库连接池对象。为了避免在多个地方重复创建数据库连接池对象，我们可以使用单例模式来确保该对象只会被创建一次，并且在多个线程之间共享一个对象。

import threading
class DatabaseConnectionPool:
    instance = None
    lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            with cls.lock:
                if cls.instance is None:
                    cls.instance = super().__new__(cls)
        return cls.instance

    def __init__(self):
        self.connections = []


    def add_connection(self, connection):
        self.connections.append(connection)

    def get_connection(self):
        return self.connections


# 使用示例
pool = DatabaseConnectionPool()
pool.add_connection("connection1")
pool.add_connection("connection2")

def worker(i):
    pool = DatabaseConnectionPool() # 多个线程共享同一个对象
    pool.add_connection("connection"+str(i+1))
    connection = pool.get_connection()
    print(f'Thread-{threading.get_ident()} got connection:{connection}')

if __name__ == '__main__':
    for i in range(4):
        t = threading.Thread(target=worker(i))
        t.start()

上述代码中，我们首先定义了一个名为 DatabaseConnectionPool 的单例类，它维护了一个连接池列表 connections，通过 add_connection 和 get_connection 方法来添加和获取连接。使用 __new__ 方法来创建单例对象，确保在多个线程之间只有一个实例，同时使用锁来保证线程安全。
然后，我们在多个线程中使用同一个连接池对象，并通过 get_connection 方法来获取连接。由于所有的线程都共享同一个连接池对象，因此在获取连接时不会出现资源浪费和重复创建对象等问题。