單例模式是一種常用的設(shè)計模式琼稻，旨在確保一個類只有一個實例粱腻，并為應(yīng)用程序提供一個全局訪問點。Python 語言中實現(xiàn)單例模式的方法有很多售睹，每種方法都有其獨特的優(yōu)缺點和適用場景。以下將逐步介紹幾種常見的單例模式實現(xiàn)方式惭笑，并且詳細(xì)拆解每種變體的代碼和應(yīng)用場景侣姆。
1. 使用模塊級變量實現(xiàn)單例模式
在 Python 中，模塊本身就是單例的沉噩，因為當(dāng)模塊被導(dǎo)入時捺宗，Python 會將其緩存，并且同一模塊不會被重新導(dǎo)入多次川蒙⊙晾鳎基于這一特性，我們可以直接通過模塊級變量來實現(xiàn)單例模式畜眨。
# singleton_module.py
class Singleton:
def __init__(self):
self.value = "This is a singleton instance."
singleton_instance = Singleton()
# main.py
from singleton_module import singleton_instance
print(singleton_instance.value)
在這個實現(xiàn)中昼牛，singleton_instance 是一個全局的模塊級實例，無論在哪個模塊中導(dǎo)入 singleton_module康聂，singleton_instance 都會保持唯一性贰健。這種方式簡潔而有效，適合于簡單場景恬汁。
2. 使用類變量來實現(xiàn)單例模式
可以使用類變量來實現(xiàn)單例模式伶椿，通過將實例保存在類變量中確保類的實例只能被創(chuàng)建一次。這種方式利用了 Python 類變量的特點。
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
def __init__(self, value):
self.value = value
# 驗證是否為單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "second instance"
在這里脊另，
__new__ 方法用于控制對象的創(chuàng)建导狡。如果 _instance 是 None，則創(chuàng)建新對象并將其存儲在 _instance 中偎痛。在之后的每次調(diào)用中都會返回已經(jīng)存在的 _instance旱捧。
3. 使用裝飾器實現(xiàn)單例模式
裝飾器是一種優(yōu)雅的 Python 語法，可以用來包裝函數(shù)或者類踩麦。我們可以定義一個裝飾器來為類提供單例模式的特性枚赡。
def singleton(cls):
instances = {}
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton
class Singleton:
def __init__(self, value):
self.value = value
# 驗證是否為單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
這個裝飾器實現(xiàn)了對 Singleton 類的包裝，并且確保 Singleton 只能創(chuàng)建一個實例靖榕。instances 字典用來存儲每個被裝飾類的實例标锄，只有在實例不存在時才創(chuàng)建新的實例。
4. 使用元類實現(xiàn)單例模式
元類是一種更為高級的實現(xiàn)單例模式的方式茁计。在 Python 中料皇，元類控制類的創(chuàng)建過程，因此可以通過元類實現(xiàn)對實例創(chuàng)建的控制星压。
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
instance = super(SingletonMeta, cls).__call__(*args, **kwargs)
cls._instances[cls] = instance
return cls._instances[cls]
class Singleton(metaclass=SingletonMeta):
def __init__(self, value):
self.value = value
# 驗證是否為單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
在這個實現(xiàn)中践剂，SingletonMeta 是 Singleton 類的元類。通過重載 __call__ 方法娜膘，可以控制實例的創(chuàng)建過程逊脯，并確保只有一個實例存在。這種方式的靈活性很高竣贪，適用于需要更精細(xì)控制類行為的場景军洼。
5. 使用 threading.Lock 來實現(xiàn)線程安全的單例模式
在多線程環(huán)境中，需要確保單例模式的實現(xiàn)是線程安全的演怎∝罢可以使用 threading.Lock 來實現(xiàn)這一點，從而防止多個線程同時創(chuàng)建實例爷耀。
import threading
class Singleton:
_instance = None
_lock = threading.Lock()
def __new__(cls, *args, **kwargs):
if not cls._instance:
with cls._lock:
if not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
def __init__(self, value):
self.value = value
# 驗證是否為單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
這里使用了雙重檢查鎖定的機(jī)制甘桑。_lock 確保了線程在進(jìn)入創(chuàng)建實例的代碼塊時互斥，防止多個線程同時創(chuàng)建不同的實例歹叮。雙重檢查則減少了加鎖帶來的性能損耗跑杭，只有在 _instance 為 None 的情況下才會加鎖創(chuàng)建實例。
6. 使用 __dict__ 屬性共享來實現(xiàn)偽單例
在一些情況下咆耿，我們可能需要多個實例德谅，但它們共享相同的數(shù)據(jù)。這種情況下可以通過 __dict__ 屬性來實現(xiàn)偽單例萨螺。
class Borg:
_shared_state = {}
def __init__(self):
self.__dict__ = self._shared_state
class Singleton(Borg):
def __init__(self, value):
super().__init__()
self.value = value
# 驗證是否為偽單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # False
print(singleton1.value) # "second instance"
在這個實現(xiàn)中窄做，Borg 類的所有實例共享同一個 __dict__ 屬性宅荤，因此它們的狀態(tài)是共享的。這種模式被稱為 Borg 模式浸策，與傳統(tǒng)的單例模式不同的是，它允許多個實例惹盼，但這些實例共享同樣的狀態(tài)庸汗。
7. 使用 importlib 實現(xiàn)懶加載的單例模式
有時候單例模式的實例可能比較占用資源，只有在確實需要時才創(chuàng)建實例是一種更高效的方法手报◎遣眨可以使用 importlib 模塊來實現(xiàn)懶加載的單例模式。
import importlib
class Singleton:
def __init__(self, value):
self.value = value
singleton_instance = None
def get_singleton_instance(value=None):
global singleton_instance
if singleton_instance is None:
module = importlib.import_module(__name__)
singleton_instance = getattr(module, 'Singleton')(value)
return singleton_instance
# 驗證是否為單例
singleton1 = get_singleton_instance("first instance")
singleton2 = get_singleton_instance("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
這個實現(xiàn)中掩蛤，只有在調(diào)用 get_singleton_instance 函數(shù)時才會實際創(chuàng)建 Singleton 的實例枉昏。importlib 模塊允許動態(tài)地導(dǎo)入模塊，并獲取其中的類和函數(shù)揍鸟，從而實現(xiàn)懶加載兄裂。這種方式適合那些資源消耗較大的單例對象，只有在需要時才去初始化它們阳藻。
8. 使用 WeakValueDictionary 防止內(nèi)存泄漏
在某些應(yīng)用中晰奖，我們需要實現(xiàn)單例的行為，但又不希望對象被持久化引用腥泥，導(dǎo)致內(nèi)存泄漏匾南。可以使用 weakref.WeakValueDictionary 來實現(xiàn)蛔外。
import weakref
class Singleton:
_instances = weakref.WeakValueDictionary()
def __new__(cls, *args, **kwargs):
if cls not in cls._instances:
instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
cls._instances[cls] = instance
return cls._instances[cls]
def __init__(self, value):
self.value = value
# 驗證是否為單例
singleton1 = Singleton("first instance")
singleton2 = Singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
WeakValueDictionary 允許對對象的弱引用蛆楞，當(dāng)對象沒有其他強(qiáng)引用時會被自動垃圾回收。這樣可以確保單例對象在沒有其他引用時被自動銷毀夹厌，防止內(nèi)存泄漏豹爹。
9. 使用基于 dataclass 的單例實現(xiàn)
在 Python 3.7+ 中引入了 dataclass，可以使用 dataclass 的方式實現(xiàn)單例模式尊流。
from dataclasses import dataclass
@dataclass
class Singleton:
value: str
_instance = None
@classmethod
def get_instance(cls, value=None):
if cls._instance is None:
cls._instance = cls(value)
return cls._instance
# 驗證是否為單例
singleton1 = Singleton.get_instance("first instance")
singleton2 = Singleton.get_instance("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
dataclass 簡化了類的定義帅戒，自動生成了 __init__ 方法等。這種實現(xiàn)方式保持了 dataclass 的簡潔性崖技，同時通過類方法 get_instance 來控制實例的創(chuàng)建逻住。
10. 使用 functools.lru_cache 實現(xiàn)單例
Python 中的 functools.lru_cache 裝飾器也可以用于實現(xiàn)單例模式，因為它可以緩存函數(shù)的返回值迎献，保證函數(shù)在相同輸入下只會執(zhí)行一次瞎访。
from functools import lru_cache
@lru_cache(maxsize=None)
def get_singleton(value):
class Singleton:
def __init__(self, value):
self.value = value
return Singleton(value)
# 驗證是否為單例
singleton1 = get_singleton("first instance")
singleton2 = get_singleton("second instance")
print(singleton1 is singleton2) # True
print(singleton1.value) # "first instance"
通過 lru_cache 實現(xiàn)了緩存功能，maxsize=None 意味著沒有緩存大小的限制吁恍，只要輸入的參數(shù)一致扒秸，返回的實例就是唯一的播演。這種方式適合那些函數(shù)式編程場景下的單例實現(xiàn)。
總結(jié)
以上介紹了在 Python 中實現(xiàn)單例模式的多種方法伴奥，每種方法都有其適用的場景和優(yōu)缺點：
- 模塊級變量實現(xiàn)適用于最簡單的場景写烤，代碼易于理解且無需額外的同步控制。
- 使用類變量實現(xiàn)是一種經(jīng)典的單例實現(xiàn)方式拾徙，適合于控制類實例化的場景洲炊。
- 使用裝飾器是一種非常優(yōu)雅的方式，適用于需要給多類增加單例特性的場景尼啡。
- 使用元類可以精細(xì)控制類的行為暂衡，是一種比較高級的實現(xiàn)方式，適用于對類的創(chuàng)建過程有更多需求的場合崖瞭。
- 使用線程鎖來確保線程安全適用于多線程環(huán)境狂巢，確保單例實例不會被重復(fù)創(chuàng)建。
-
Borg模式適用于需要共享狀態(tài)但允許創(chuàng)建多個實例的場景书聚，保持了類的靈活性唧领。 - 懶加載單例適用于那些創(chuàng)建成本較高，只有在確實需要時才去創(chuàng)建的場景雌续。
- 使用
WeakValueDictionary可以有效防止內(nèi)存泄漏疹吃，適用于短生命周期的單例對象。 - 基于
dataclass的實現(xiàn)保留了代碼的簡潔性西雀，同時實現(xiàn)了單例的特性萨驶。 - 使用
lru_cache實現(xiàn)單例適用于函數(shù)式編程風(fēng)格的應(yīng)用場景，簡潔且高效艇肴。
