python3 單例模式

單例模式是某個類在整個系統中只存在一個實例的一種設計模式。

使用單例模式的好處：

1. 單例模式不僅可以減少內存資源占用，而且因為只初始化一次，還可以加快運行性能。例如當程序通過一個類來讀取配置信息，而程序多個地方需要使用配置信息，這時整個程序運行過程中只需一個實例對象即可，可減少占用內存資源，同時還可以保證程序在多處地方獲取的配置信息一致。
2. 使用單例模式可進行同步控制，計數器同步、程序多處讀取配置信息這些情景下若只存在一個實例，即可保證一致性。

Python實現單例模式有4種方式：

1. 通過模塊調用
2. 使用__new__方法
3. 使用裝飾器
4. 使用元類（metaclass） 

 

一、通過模塊調用

在python3中，首次導入模塊文件時，會在程序目錄下的__pycache__目錄中生成pyc文件，再導入時，將直接加載pyc文件。因此，只需把相關的函數和數據定義在一個模塊中，就可以獲得一個單例對象了。

• 定義singleton_demo.py模塊

class singleton_cal:
    def foo(self)
        pass
 

export_singleton = singleton_cal()

• 使用模塊

from singleton_demo import export_singleton


a = export_singleton
b = export_singleton

print(id(a) == id(b))

 

二、使用__new__方法

1. __new__：創建實例對象時調用的構造方法
2. __init__ ：實例初始化方法，用於設置實例的相關屬性

當實例化一個對象時，先調用__new__方法（未定義時調用object.__new__）實例化對象，然后調用__init__方法進行對象初始化。

所以，可以聲明一個私有類變量__instance。當__instance不為None時，表示系統中已有實例，直接返回該實例；若__instance為None時，表示系統中還沒有該類的實例，則創建新實例並返回。

class Singleton(object):
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super().__new__(cls, *args, **kwargs)
        return cls.__instance


a = Singleton()
b = Singleton()
print(id(a) == id(b))

 

三、使用裝飾器

from functools import wraps


def singleton(cls):
    instances = {}

    @wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance


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


a = Singleton()
b = Singleton()
print(id(a) == id(b))

只有第一次調用Singleton類時，裝飾器才會從instances={}開始執行，以后再調用該類時，都只執行get_instance函數，這是裝飾器的特性。

利用裝飾器的這個特性，可以實現單例模式。復用裝飾器，可以使多個類實現單例模式。

 

四、使用元類

元類創建了所有的類型對象（包括object對象），系統默認的元類是type。

執行順序：先定義metaclass，然后在類定義時，通過metaclass創建類，最后通過定義好的類創建實例。

所以，metaclass允許你創建類或者修改類。換句話說，可以把類看成是metaclass創建出來的“實例”。

元類中定義的__new__方法，在以該類為元類的類定義時自動調用。例如：類A以類B為元類，當定義類A時，類B的__new__方法將會被自動調用。

元類中定義的__call__方法，在以該類為元類的類創建實例時自動調用。例如：類A以類B為元類，當類A創建實例時，類B的__call__方法將會被自動調用。

1、元類的使用

自定義元類時，通常繼承自type。

class MetaClass(type):
    def __init__(cls, *args, **kwargs):
        # cls 代指以該類為元類的類 Foo
        super(MetaClass, cls).__init__(*args, **kwargs)
    
    def __new__(mcs, *args, **kwargs):
        # mcs 代指元類自身
        print("MetaClass.__new__: ", mcs)
        return super().__new__(mcs, *args, **kwargs)

    def __call__(cls, *args, **kwargs):
        # cls 代指以該類為元類的類 Foo
        print("CLS: ", cls)
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs)
        return obj


class Foo(metaclass=MetaClass):
    # 定義類Foo時，將調用元類的__new__方法和__init__方法。就跟一般普通類實例化時調用__new__方法和__init__方法一樣。
    def __init__(self, name):
        self.name = name


# Foo 實例化時會調用元類的__call__方法。
a = Foo("ABC")

2、元類實現單例模式

聲明一個私有變量__instance保存類實例。__instance為None時，調用type的__call__方法為類創建實例。

class SingletonMeta(type):
    __instance = None
    def __call__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = type.__call__(cls, *args, **kwargs)
        return cls.__instance


class MyClass(metaclass=SingletonMeta):
    def foo(self):
        pass


a = MyClass()
b = MyClass()
print(id(a) == id(b))

 

五、使用類

class Singleton(object):
    def __init__(self):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

線程安全

通過以上方法定義的單例模式，無法支持多線程。解決這個問題的辦法是：加鎖！未加鎖部分並發執行，加鎖部分串行執行。

import threading


class Singleton(object):
    _instance_lock = threading.Lock()

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def task(arg):
    obj = Singleton.instance()
    print("Task {}".format(arg), id(obj))


for i in range(10):
    t = threading.Thread(target=task, args=[i,])
    t.start()

 使用類實現的單例模式，在使用時必須通過Singleton.instance()進行實例化。如果使用Singleton()進行實例化得到的不是單例。