技術標籤：Pythonsingleton單例模式

Python實現Singleton模式的幾種方式

參考：https://www.cnblogs.com/yssjun/p/9858420.html

使用python實現設計模式中的單例模式。單例模式是一種比較常用的設計模式，其實現和使用場景判定都是相對容易的。本文將簡要介紹一下python中實現單例模式的幾種常見方式和原理。一方面可以加深對python的理解，另一方面可以更加深入的瞭解該模式，以便實際工作中能更加靈活的使用單例設計模式。

本文將介紹常見的實現單例模式的幾種方式，這裡暫不考慮多執行緒的情況。

為了準備該篇博文，之前寫了幾篇相關的文章依次完整的介紹了相關的概念，下面會在需要的時候給出連結。

裝飾器作為python實現單例模式的一種常用方法，先簡單瞭解一下其概念。

1.裝飾器

裝飾器(Decorator)可以用作對函式以及類進行二次包裹或者封裝，使用方式@wrapper。

def f(...):
    ...
f = staticmethod(f)

@staticmethod
def f(...):
    ...

上面這兩種方式對函式的定義在語法上是等價的。當然對於類也有同樣的用法，類可以作為裝飾器也可以作為被裝飾物件。唯一的區別就是經過包裹的類可能不在是一個類，而是一個類的物件或者一個函式，這取決於裝飾器返回的值。

經過Decorator裝飾的類或者函式本質上已經不再是原來的類或者函數了。但是，實際上在包裹之後得到的新物件仍然擁有被包裹物件的特性（這句是不是廢話：-））。

在python中我們經常只需要實現一個裝飾器，然後使用該裝飾器作用於只能有唯一一個例項的類。這樣只需要實現一個這樣的裝飾器，便可以作用於任何一個想要唯一例項的類。

2.閉包方式

閉包的應用很多，單例模式則是其應用之一。先看程式碼：

 1 def singleton(cls):
 2     instances = {}
 3     
 4     def getinstance(*args, **kwargs):
 5         if cls not in instances:
 6             instances[cls] = cls(*args, **kwargs)
 7         return instances[cls]
 8     return getinstance
 9 
10 @singleton
11 class my_cls(object):
12     pass
 

這個實現單例模式的方式將原來類的定義隱藏在閉包函式中，通過閉包函式及其中引用的自由變數來控制類物件的生成。由於唯一的例項存放在自由變數中，而且自由變數是無法直接在指令碼層進行訪問的。這種方式非常隱蔽的保護例項不被修改，因此很適合用於單例模式。

這種方式簡單明瞭，很容易實現。但是如果不瞭解閉包實現過程和變數的繫結等概念可能會不明白其實現的過程。建議參考一下我的另一篇博文：理解python閉包概念。

這裡一個很有趣的地方是為什麼要使用instances = {}這樣一個變數？可不可以不用字典，使用instance = None？如果singleton作為裝飾器被多個不同的類使用，那麼instance中會存在幾個不同的例項麼？

有時間可以思考一下這幾個問題，答案也可以在我寫的閉包相關的博文中找到。

3.元類方式

所謂單例模式，即我們需要控制類例項的生成過程，並且保證全域性只可能存在一個唯一的例項。既然需要在建立類的物件過程中做些什麼，應該很容易想到元類。參照介紹元類的文章：python metaclass深入分析。

 1 class Singleton(type):
 2     def __init__(cls, name, bases, dic):
 3         super(Singleton, cls).__init__(name, bases, dic)
 4         cls._instance = None
 5 
 6     def __call__(cls, *args, **kwargs):
 7         if cls._instance is None:
 8             cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
 9             # cls._instance = cls(*args, **kwargs)    # Error! Lead to call this function recursively
10         return cls._instance
11 
12 class my_cls(object):
13     __metaclass__ = Singleton

這個例子中我們使用元類Singleton替代預設使用type方式建立類my_cls。可以將類my_cls看做是元類Singleton的一個物件，當我們使用my_cls(...)的方式建立類my_cls的物件時，實際上是在呼叫元類Singleton的物件my_cls。

物件可以以函式的方式被呼叫，那麼要求類中定義__call__函式。不過此處被呼叫的是類，因此我們在元類中定義函式__call__來控制類my_cls物件建立的唯一性。

這種方式的弊端之一就是類唯一的物件被存放在類的一個靜態資料成員中，外部可以通過class_name._instance的方式修改甚至刪除這個例項(該例中my_cls._instance = None完全合法)。

4.類作為裝飾器之__call__方式

不僅函式可以作為裝飾器，類也可以作為裝飾器。

下面簡單的介紹一下使用類作為裝飾器實現單例模式的另一種方式。

 1 class Singleton(object):
 2     _INSTANCE = {}
 3     def __init__(self, cls):
 4         self.cls = cls
 5         
 6     def __call__(self, *args, **kwargs):
 7         instance = self._INSTANCE.get(self.cls, None)
 8         if not instance:
 9             instance = self.cls(*args, **kwargs)
10             self._INSTANCE[self.cls] = instance
11         return instance
12     
13     def __getattr__(self, key):
14         return getattr(self.cls, key, None)
15 
16 @Singleton
17 class my_cls(object):
18     pass

函式作為裝飾器返回的是一個函式，函式被呼叫過程中實際上是間接地呼叫其內部包裹的被裝飾的物件。

類作為裝飾器要想達到相同的效果只需要將類的物件返回，並且其物件是可以呼叫的。這是上面這個例子表達的一個核心思想。

這種方式寫法很多，也很靈活，其思想基本上就是對被包裹物件的呼叫實際上呼叫的是類物件的__call__函式，該函式實際上是對被裝飾物件的一次封裝。

5.類本身實現方式

上面的例子中我們都是使用的裝飾器或者元類的方式間接的通過控制類物件生成的方式來保證物件的唯一性，那麼有沒有辦法直接在類中通過某種方式保證類物件的唯一性？

答案是肯定的。參考我之前寫的一篇介紹元類的文章，可知生成物件前會呼叫函式__new__，如果__new__函式返回被建立的物件，那麼會自動呼叫類中定義的__init__函式進行物件的初始化操作。

相信讀了上面這句話，應該知道我們接下來要幹什麼了？沒錯，我們的目標就是__new__。

 1 class MSC(object):
 2     _INSTANCE = None
 3 
 4     def __new__(cls, *args, **kwargs):
 5         if not cls._INSTANCE:
 6             cls._INSTANCE = super(MSC, cls).__new__(cls, *args, **kwargs)
 7             # cls._INSTANCE.args = args
 8             # cls._INSTANCE.kwargs = kwargs
 9         return cls._INSTANCE
10 
11     def __init__(self, *args, **kwargs):
12         pass

在這個例子中，我們完全可以理解為什麼只會有一個類的物件會被建立。這種方式的定義決定了類本身只能被建立一個物件。

但是這裡有一點需要注意，那就是不管建立多少MSC的物件，至始至終只會有一個物件，但是如果每次建立的時候傳入的引數都不同，也就是__init__函式中引數不同，會導致同一個物件被多次初始化。

這種方式的弊端顯然很明顯，那就是該方法只能作用於單個類的定義。不能像上面的裝飾器和元類，一次實現，可以到處使用。

那能不能將這個控制類生成過程的結構單獨抽象出來呢？而且有沒有什麼方法能防止同一個物件多次被__init__初始化。下面我們看一種能被不同的類使用的更加抽象的結構。

6.替換__new__方式

我們定義的類作為一個物件，通過替換其部分屬性可以達到控制類物件生成的目的。

 1 def Singleton(cls):
 2     _instance = {}
 3     cls._origin_new = cls.__new__
 4     cls._origin_init = cls.__init__
 5     @functools.wraps(cls.__new__)
 6     def _singleton_new(cls, *args, **kwargs):
 7         if cls not in _instance:
 8             sin_instance = cls._origin_new(cls, *args, **kwargs)
 9             sin_instance._origin_init(*args, **kwargs)
10             _instance[cls] = sin_instance
11         return _instance[cls]
12     # As a special case,__new__ is a staticmethod, need convert function to staticmethod by self 
13     cls.__new__ = staticmethod(_singleton_new)
14     # setattr(cls, '__new__', staticmethod(_singleton_new))
15     cls.__init__ = lambda self, *args, **kwargs: None
16     # setattr(cls, '__init__', lambda self, *args, **kwargs: None)
17     return cls
18 
19 @Singleton
20 class my_cls(object):
21     pass

上面我們通過替換類的__new__函式和__init__函式的方式，保證被Singleton裝飾的類只有一個物件會被原來的__new__和__init__生成和初始化。

這裡必須要替換類的__init__函式，而且該函式應該什麼都不做。原因在於替換之後的__new__返回唯一的物件後，會自動呼叫現在的__init__函式。

原來的__init__函式已經在建立唯一一個物件時被呼叫過。而且只能被呼叫一次。

這裡返回的並不是閉包結構，只是使用裝飾器修改了類的部分屬性，返回的仍是傳入的類。但是類的__new__函式引用了Singleton中的local variable _instance。

my_cls.__new__.func_closure[0].cell_contents 
== 
{<class '__main__.my_cls'>: <__main__.my_cls object at 0x02954810>}
==
_instance

Cell 物件my_cls.__new__.func_closure[0]中存放的便是類my_cls唯一的例項。

當然我們可以將my_cls唯一的物件作為類的一個靜態資料成員放入cls.__dict__中來替代_instance = {}，但是顯然閉包結構更適合。

7.注意事項

文中藉助python語言的類建立物件過程的相關原理，介紹了幾種不同的單例模式實現方式。

為了保留被裝飾物件的一些屬性，可以使用@functools.wraps的方式對返回的閉包進行裝飾。

平時建議使用前兩種實現方式，也就是閉包方式和元類方式。其他情況多少有點玩弄python語法技巧的一些嫌疑，當然了，作為學習python來說還是比較有意義的。

建議多關注語言特性的應用以及如何的解決實際的問題，不要沉迷於語言實現的一些細枝末節。本末倒置總會有些得不償失嘛。尤其是python作為一種非常實用的語言。

本文介紹中如果有什麼不當之處歡迎指正，如果有其他的更好的實現方式也請不吝賜教。

歡迎轉載部落格文章,轉載請標明出處!

Python實現Singleton模式，可以用於搭建資料庫連線池

參考：https://blog.csdn.net/lqxqust/article/details/51910007

Singleton模式即單例物件必須必須保證只有一個例項存在。可以說Singleton是設計模式中最基本一種設計模式，在學習設計模式時一般都會先了解該模式。在Python中實現單例模式有很多方法，下面簡單總結以下，可以根據情況選擇適合自己業務場景的一種進行實現。
1. 如果在C++中實現過單例模式，在Python中比較常想到的實現方法是藉助__new__方法實現:

class Singleton(object):
    instance = None
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls, *args, **kwargs)
        return cls.instance

t1 = Singleton()
t2 = Singleton()
assert id(t1) == id(t2)

該方法基本可以保證只有一個例項，但存在併發的問題。
2. 在C++中實現Singleton模式的時候也會考慮多執行緒的問題，在Pyhton中同樣存在該問題，可以通過加鎖進行解決。

import threading 

class Singleton(object):
    vars = {}
    single_lock = threading.Lock()
    def __new__(cls, *args, **kwargs):
        if cls in cls.vars:
            return cls.vars[cls]
        cls.single_lock.acquire()
        try:
            if cls in cls.vars:
                return cls.vars[cls]
            cls.vars[cls] = super().__new__(cls, *args, **kwargs)
            return cls.vars[cls]
        finally:
            cls.single_lock.release()

以上兩種都是在類似C++的語言中實現的常用方法，但是在Python中實現不那麼Pytonic，並且被子類過載可能還存在問題。
3. 在《改善Python程式的91個建議》中介紹了一種方法，Python的import機制天然支援單例的實現。
1. 所有變數都會繫結到模組
2. 模式只初始化一次
3. import機制是執行緒安全的
該放很多情況下都可以滿足單例的使用，實現有時覺得有點隱晦。
4. 有沒有更Pythnic得方法，並且有比較易於使用的呢？大Python當時是無所不能了O(∩_∩)O~，通過使用元類來實現。元類就是用來控制建立類的類。

class SingletonMeta(type):
    def __init__(cls, name, bases, namespaces):
        super().__init__(cls, name, bases, namespaces)
        cls.instance = None
    def __call__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__call__(*args, **kwargs)
        else:
            print("instance already existed!")
        return cls.instance

class Singleton(meta=Singleton):
    pass

t1 = Singleton()
t2 = Singleton()

實現了__call__方法這個類就成為可呼叫的，類似於過載了括號操作符，因為在元類中實現__call__，則使用Singleton()例項化類時就會呼叫__call__，對其進行了單例建立的控制。
4. 還有一種Pythonic的方法時使用decorator實現

def singleton(cls, *args, **kwargs):
    instances = {}
    def wrapper():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return _wrapper

@singleton
class Singleton(object):
    pass

t1 = Singleton()
t2 = Singleton()

以上是Python中常見的實現單例模式的方法，在實際開發中，可以根據應用場景選擇自己喜歡的方式實現，個人覺得通過元類或裝飾器方式實現還是非常的方便和Pythonic。