Python實現Singleton模式的幾種方式

使用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作為一種非常實用的語言。

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