你真的了解Python的單例模式嗎?

最近在用Python單例模式的時候遇到一些問題, 還是自己太年輕了, 在這里總結一下我在使用這個設計模式的時候的坑.

前言(單例模式簡介)

單例模式提供了這樣一個機制，即確保類有且只有一個特定類型的對象，并提供全局訪問點。因此，單例模式通常用于下列情形，例如日志記錄或數據庫操作、打印機后臺處理程序，以及其他程序——該程序運行過程中只能生成一個實例，以避免對同一資源產生相互沖突的請求。例如，我們可能希望使用一個數據庫對象對數據庫進行操作，以維護數據的一致性；或者希望使用一個日志類的對象，將多項服務的日志信息按照順序轉儲到一個特定的日志文件中。

簡單來說, 單例模式可以總結為下面三個要點:

• 確保類有且只有一個對象被創建。
• 為對象提供一個訪問點，以使程序可以全局訪問該對象。
• 控制共享資源的并行訪問。

下文中, 我們將會用Python來實現單例模式, 不做特殊說明, 下文中所有的代碼均基于Python 3.6.8實現.

經典的單例模式

代碼如下所示:

class Singleton:

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


def test():
    s1 = Singleton()
    s2 = Singleton()
    print(f"s1: {s1}\ns2: {s2}")

我們來運行代碼查看一下運行結果.

可以發現上述代碼滿足如下兩個要求:

• 只允許Singleton類生成一個實例。
• 如果已經有一個實例了，會重復提供同一個對象。

懶漢實例化版單例模式

單例模式的用例之一就是懶漢式實例化。例如，在導入模塊的時候，我們可能會無意中創建一個對象，但當時根本用不到它。懶漢式實例化能夠確保在實際需要時才創建對象。所以，懶漢式實例化是一種節約資源并僅在需要時才創建它們的方式。下面我們來看一下代碼:

class LazySingleton:
    __instance = None

    def __init__(self):
        if not LazySingleton.__instance:
            print('Called __init__ method...')
        else:
            print("Instance already created @: ", self.get_instance())

    @classmethod
    def get_instance(cls):
        if not cls.__instance:
            cls.__instance = LazySingleton()
        return cls.__instance

def test():

    s1 = LazySingleton()
    print("Created Object", LazySingleton.get_instance())
    s2 = LazySingleton()

同樣來看一下代碼的運行結果,

利用元類實現單例模式

為什么會考慮到這么寫, 因為如果我想對某個類實現單例模式, 我要復制上面的一堆代碼, 這顯現不夠Pythonic, 因此考慮一下使用元類來實現. 有人可能發問了, 這為什么不用繼承來實現, 寫一個基類, 其他子類繼承他不就好了嗎? 悄悄的說一句, 如果用繼承的話是有坑的, 下面首先來看一下繼承方法為什么不可以.

來看一個簡單的例子, 還是使用前面所說的簡單單例.

class Singleton:

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


class FirstChildSingleton(Singleton):
    pass


class SecondChildSingleton(Singleton):
    pass


def test():
    s1 = Singleton()
    s2 = Singleton()
    print(f"s1: {s1}\ns2: {s2}")

    first_child = FirstChildSingleton()
    second_child = SecondChildSingleton()
    print(f"first child: {first_child}\nsecond child: {second_child}")

打印一下結果, 可以發現,

這里所有的子類也是同一個對象, 這顯然是不行的.

什么是元類

讓我們先來了解一下元類。元類是一個類的類，這意味著該類是它的元類的實例。使用元類，程序員有機會從預定義的Python類創建自己類型的類。

在Python中，一切皆對象。如果我們說a=1，則type(a)返回<type'int'>，這意味著a是int類型。但是，type(int)返回<type'type'>，這表明存在一個元類，因為int是type類型的類。

具體有關元類的知識, 在本文中不多介紹了, 不是這一篇文章的重點.

單例實現

首先還是老套路, 先來看一下代碼:

class MetaSingleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = super(MetaSingleton, cls).__call__(*args, **kwargs)
        return cls._instance


class FirstChildMetaSingleton(metaclass=MetaSingleton):
    pass


class SecondChildMetaSingleton(metaclass=MetaSingleton):
    pass


def test():
    
    s1 = FirstChildMetaSingleton()
    s2 = SecondChildMetaSingleton()
    print(f"s1: {s1}\ns2: {s2}")

我們可以發現, 這樣的話, 實例化出來的單例就不是同一個了.

線程安全的單例

你以為寫個元類, 這樣就可以解決一切問題嗎? 哈哈, 太天真了, 上述的寫法實際上是非線程安全的, 我們來看一個例子.

先來看一下代碼,

class SimpleSingleton(metaclass=MetaSingleton):
    def __init__(self):
        time.sleep(1)


def create_in_thread(name):
    s = SimpleSingleton()
    print(f'{name}: {s}')


def test():
    t1 = threading.Thread(target=create_in_thread, args=("first thread",))
    t2 = threading.Thread(target=create_in_thread, args=("second thread",))

    t1.start()
    t2.start()
    t1.join()
    t2.join()

從上圖中可以看到, 這樣會創建兩個單例, 也就是說這樣代碼是非線程安全的, 我太難了, 下面來看一個線程安全的單例吧.

class MetaThreadSecuritySingleton(type):
    _instance_lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with MetaThreadSecuritySingleton._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(MetaThreadSecuritySingleton, cls).__call__(*args, **kwargs)
        return cls._instance


class SimpleThreadSecuritySingleton(metaclass=MetaThreadSecuritySingleton):
    def __init__(self):
        time.sleep(1)


def create_in_thread(name):
    s = SimpleThreadSecuritySingleton()
    print(f'{name}: {s}')


def test():
    t1 = threading.Thread(target=create_in_thread, args=("first thread",))
    t2 = threading.Thread(target=create_in_thread, args=("second thread",))

    t1.start()
    t2.start()
    t1.join()
    t2.join()

最終這個單例終于變得線程安全了, 生活中處處充滿著驚喜, 微笑著面對它, 奧利給.