簡單而言，單例模式就是保證某個例項在專案的整個生命週期中只存在乙個，在專案的任意位置使用，都是同乙個例項。
單例模式雖然簡單，但還是有些門道的，而少有人知道這些門道。
邊界情況
python中實現單例模式的方法很多，我以前最常使用的應該是下面這種寫法。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.單例模式對應類例項化時無法傳入引數，將上面的**擴充套件成下面形式。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 = y
s = 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):
with threading.lock():
return func(*args, **kwargs)
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()將單例化方法同步化，這樣在面對多個執行緒時也不會出現建立多個例項的情況，可以簡單試驗一下。def worker():
s = singleton()
print(id(s))
def test():
task =
for i in range(10):
t = threading.thread(target=worker)
for i in task:
i.start()
for i in task:
i.join()
test()
執行後，列印的單例的id都是相同的。
更優的方法
加了同步鎖之後，除了無法傳入引數外，已經沒有什麼大問題了，但是否有更優的解決方法呢？單例模式是否有可以接受引數的實現方式？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
@singleton
class 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__方法將引數傳遞給當前類，從而完成單
例模式的目的。
這種方法讓單例類可以接受對應的引數但面對多執行緒同時例項化還是可能會出現多個例項，此時加上執行緒同步鎖則可。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
是否加同步鎖的額外考慮
如果乙個專案不需要使用執行緒相關機制，只是在單例化這裡使用了執行緒鎖，這其實不是必要的，它會拖慢專案的執行速度。
才會呼叫pyeval_initthreads方法初始化多執行緒相關的環境，**片段如下(我省略了很多不相關**)。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鎖的情況下會執行的更快。
如果你的專案中不會涉及多執行緒操作，那麼就沒有使用有同步鎖來實現單例模式。
結尾網際網路中有很多python實現單例模式的文章，你只需要從多執行緒下是否可以保證單例項以及單例化時是否可以傳入初始引數兩點來判斷
相應的實現方法則可。
python單例模式繼承 python單例模式
我們可以使用 new 這個特殊方法。該方法可以建立乙個其所在類的子類的物件。更可喜的是，我們的內建 object 基類實現了 new 方法，所以我們只需讓 sing 類繼承 object 類，就可以利用 object 的 new 方法來建立 sing 物件了。classsing object def...
單例模式 python
單例模式 保證乙個類僅有乙個例項，並提供乙個訪問它的全域性訪問點。實現 某個類只有乙個例項 途徑 1 讓乙個全域性變數使得乙個物件被訪問，但是它不能防止外部例項化多個物件。2 讓類自身負責儲存它的唯一例項。這個類可以保證沒有其他例項可以被建立。即單例模式。多執行緒時的單例模式 加鎖 雙重鎖定。餓漢式...
python單例模式
new 在 init 之前被呼叫，用於生成例項物件。利用這個方法和類的屬性的特點可以實現設計模式的單例模式。單例模式是指建立唯一物件，單例模式設計的類只能例項 例項化1個物件。class singleton object instance none def init self pass def ne...