python3 單例模式

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

使用單例模式的好處：

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

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

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

 

1、經過模塊調用

在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))

 

2、使用__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))

 

3、使用裝飾器

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函數，這是裝飾器的特性。

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

 

4、使用元類

元類建立了全部的類型對象（包括object對象），系統默認的元類是type。

執行順序：先定義metaclass，而後在類定義時，經過metaclass建立類，最後經過定義好的類建立實例。

因此，metaclass容許你建立類或者修改類。換句話說，能夠把類當作是metaclass建立出來的「實例」。

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

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

一、元類的使用

自定義元類時，一般繼承自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")

二、元類實現單例模式

聲明一個私有變量__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))

 

5、使用類

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()進行實例化獲得的不是單例。