單例模式雖然簡單，但還是有些門道的，而少有人知道這些門道。
邊界情況
Python中實現單例模式的方法很多，我以前最常使用的應該是下面這種寫法。
1 2 3 4 5 6 7 | class Singleton(object): _instance = None def __new__(cls, *args, **kw): if cls._instance is None: cls._instance = object.__new__(cls, *args, **kw) return cls._instance |
這種寫法有兩個問題。
1.單例模式對應類實例化時無法傳入參數，將上面的代碼擴展成下面形式。
1 2 3 4 5 6 7 8 9 10 11 12 13 | class Singleton(object): _instance = None def __new__(cls, *args, **kw): if cls._instance is None: cls._instance = object.__new__(cls, *args, **kw) return cls._instance def __init(self, x, y): self.x = x self.y = ys = Singleton(1,2) |
此時會拋出TypeError: object.__new__() takes exactly one argument (the type to instantiate)錯誤
2.多個線程實例化Singleton類時，可能會出現創建多個實例的情況，因為很有可能多個線程同時判斷cls._instance is None，從而進入初
始化實例的代碼中。
基于同步鎖實現單例
先考慮上述實現遇到的第二個問題。
既然多線程情況下會出現邊界情況從而參數多個實例，那么使用同步鎖解決多線程的沖突則可。
import threading # 同步鎖 def synchronous_lock(func): def wrapper(*args, **kwargs): with threading.Lock(): return func(*args, **kwargs) return wrapper class Singleton(object): instance = None @synchronous_lock def __new__(cls, *args, **kwargs): if cls.instance is None: cls.instance = object.__new__(cls, *args, **kwargs) return cls.instance
上述代碼中通過threading.Lock()將單例化方法同步化，這樣在面對多個線程時也不會出現創建多個實例的情況，可以簡單試驗一下。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | def worker(): s = Singleton() print(id(s))def test(): task = [] for i in range(10): t = threading.Thread(target=worker) task.append(t) for i in task: i.start() for i in task: i.join()test() |
運行后，打印的單例的id都是相同的。
更優的方法
加了同步鎖之后，除了無法傳入參數外，已經沒有什么大問題了，但是否有更優的解決方法呢？單例模式是否有可以接受參數的實現方式？
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | def singleton(cls): cls.__new_original__ = cls.__new__ @functools.wraps(cls.__new__) def singleton_new(cls, *args, **kwargs): it = cls.__dict__.get('__it__') if it is not None: return it cls.__it__ = it = cls.__new_original__(cls, *args, **kwargs) it.__init_original__(*args, **kwargs) return it cls.__new__ = singleton_new cls.__init_original__ = cls.__init__ cls.__init__ = object.__init__ return cls @singletonclass Foo(object): def __new__(cls, *args, **kwargs): cls.x = 10 return object.__new__(cls) def __init__(self, x, y): assert self.x == 10 self.x = x self.y = y |
上述代碼中定義了singleton類裝飾器，裝飾器在預編譯時就會執行，利用這個特性，singleton類裝飾器中替換了類原本的__new__與
__init__方法，使用singleton_new方法進行類的實例化，在singleton_new方法中，先判斷類的屬性中是否存在__it__屬性，以此來判斷
是否要創建新的實例，如果要創建，則調用類原本的__new__方法完成實例化并調用原本的__init__方法將參數傳遞給當前類，從而完成單
例模式的目的。
這種方法讓單例類可以接受對應的參數但面對多線程同時實例化還是可能會出現多個實例，此時加上線程同步鎖則可。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | def singleton(cls): cls.__new_original__ = cls.__new__ @functools.wraps(cls.__new__) def singleton_new(cls, *args, **kwargs): # 同步鎖 with threading.Lock(): it = cls.__dict__.get('__it__') if it is not None: return it cls.__it__ = it = cls.__new_original__(cls, *args, **kwargs) it.__init_original__(*args, **kwargs) return it cls.__new__ = singleton_new cls.__init_original__ = cls.__init__ cls.__init__ = object.__init__ return cls |
是否加同步鎖的額外考慮
如果一個項目不需要使用線程相關機制，只是在單例化這里使用了線程鎖，這其實不是必要的，它會拖慢項目的運行速度。
閱讀CPython線程模塊相關的源碼，你會發現，Python一開始時并沒有初始化線程相關的環境，只有當你使用theading庫相關功能時，
才會調用PyEval_InitThreads方法初始化多線程相關的環境，代碼片段如下（我省略了很多不相關代碼）。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | static PyObject *thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs){ PyObject *func, *args, *keyw = NULL; struct bootstate *boot; unsigned long ident; // 初始化多線程環境，解釋器默認不初始化，只有用戶使用時，才初始化。 PyEval_InitThreads(); /* Start the interpreter's thread-awareness */ // 創建線程 ident = PyThread_start_new_thread(t_bootstrap, (void*) boot); // 返回線程id return PyLong_FromUnsignedLong(ident);} |
為什么會這樣？
因為多線程環境會啟動GIL鎖相關的邏輯，這會影響Python程序運行速度。很多簡單的Python程序并不需要使用多線程，此時不需要初始化線程相關的環境，Python程序在沒有GIL鎖的情況下會運行的更快。
如果你的項目中不會涉及多線程操作，那么就沒有使用有同步鎖來實現單例模式。
結尾
1.互聯網中有很多Python實現單例模式的文章，你只需要從多線程下是否可以保證單實例以及單例化時是否可以傳入初始參數兩點來判斷
相應的實現方法則可。
2..光理論是不夠的。這里順便送大家一套2020最新python入門到高級項目實戰視頻教程，可以去小編的Python交流.裙 ：七衣衣九七七巴而五（數字的諧音）轉換下可以找到了，還可以跟老司機交流討教！
