單例模式
1、內容
保證一個類只有一個例項，並提供一個訪問它的全域性訪問點
2、角色
單例
3、使用場景
當類只有一個例項而且客戶可以從一個眾所周知的訪問點訪問它時
比如：資料庫連結、Socket建立連結
4、優點
對唯一例項的受控訪問
單利相當於全域性變數，但防止了名稱空間被汙染
與單利模式功能相似的概念：全域性變數、靜態變數（方法）
試問？為什麼用單例模式，不用全域性變數呢？
答、全域性變數可能會有名稱空間的干擾，如果有重名的可能會被覆蓋
5、缺點
一、開銷 雖然數量很少，但如果每次物件請求引用時都要檢查是否存在類的例項，將仍然需要一些開銷。可以通過使用靜態初始化解決此問題。 二、可能的開發混淆 使用單例物件（尤其在類庫中定義的物件）時，開發人員必須記住自己不能使用new關鍵字例項化物件。因為可能無法訪問庫原始碼，因此應用程式開發人員可能會意外發現自己無法直接例項化此類。 三、物件生存期
不能解決刪除單個物件的問題。在提供記憶體管理的語言中（例如基於.NET Framework的語言），只有單例類能夠導致例項被取消分配，因為它包含對該例項的私有引用。在某些語言中（如 C++），其他類可以刪除物件例項，但這樣會導致單例類中出現懸浮引用
實現方式
1、檔案匯入的形式（常用）
s1.py
class Foo(object):
def test(self):
print("123")
v = Foo()
#v是Foo的例項
s2.py
from s1 import v as v1
print(v1,id(v1)) #<s1.Foo object at 0x0000000002221710> 35788560
from s1 import v as v2
print(v1,id(v2)) #<s1.Foo object at 0x0000000002221710> 35788560
# 兩個的記憶體地址是一樣的
# 檔案載入的時候，第一次匯入後，再次匯入時不會再重新載入。
複製程式碼2、基於類實現的單例模式
# ======================單例模式：無法支援多執行緒情況===============
class Singleton(object):
def __init__(self):
import time
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
import threading
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
# ====================單例模式：支援多執行緒情況================、
import time
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock: #為了保證執行緒安全在內部加鎖
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)
# 使用先說明，以後用單例模式，obj = Singleton.instance()# 示例：# obj1 = Singleton.instance()# obj2 = Singleton.instance()# print(obj1,obj2)# 錯誤示例# obj1 = Singleton()# obj2 = Singleton()# print(obj1,obj2)
複製程式碼3、基於__new__實現的單例模式（最常用）
# =============單執行緒下執行===============
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
pass
def __new__(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
# 類加括號就回去執行__new__方法，__new__方法會建立一個類例項：Singleton()
Singleton._instance = object.__new__(cls) # 繼承object類的__new__方法，類去呼叫方法，說明是函式，要手動傳cls
return Singleton._instance #obj1
#類加括號就會先去執行__new__方法，在執行__init__方法
# obj1 = Singleton()
# obj2 = Singleton()
# print(obj1,obj2)
# ===========多執行緒執行單利============
def task(arg):
obj = Singleton()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
# 使用先說明，以後用單例模式，obj = Singleton()# 示例# obj1 = Singleton()# obj2 = Singleton()# print(obj1,obj2)
複製程式碼4、基於metaclass(元類)實現的單例模式
"""
1.物件是類建立，建立物件時候類的__init__方法自動執行，物件()執行類的 __call__ 方法
2.類是type建立，建立類時候type的__init__方法自動執行，類() 執行type的 __call__方法(類的__new__方法,類的__init__方法)
# 第0步: 執行type的 __init__ 方法【類是type的物件】
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
pass
# 第1步: 執行type的 __call__ 方法
# 1.1 呼叫 Foo類（是type的物件）的 __new__方法，用於建立物件。
# 1.2 呼叫 Foo類（是type的物件）的 __init__方法，用於對物件初始化。
obj = Foo()
# 第2步：執行Foo的 __call__ 方法
obj()
"""
# ===========類的執行流程================
class SingletonType(type):
def __init__(self,*args,**kwargs):
print(self) #會不會列印？ #<class '__main__.Foo'>
super(SingletonType,self).__init__(*args,**kwargs)
def __call__(cls, *args, **kwargs): #cls = Foo
obj = cls.__new__(cls, *args, **kwargs)
obj.__init__(*args, **kwargs)
return obj
class Foo(metaclass=SingletonType):
def __init__(self,name):
self.name = name
def __new__(cls, *args, **kwargs):
return object.__new__(cls, *args, **kwargs)
'''
1、物件是類建立的，建立物件時類的__init__方法會自動執行，物件（）執行類的__call__方法
2、類是type建立的，建立類時候type類的__init__方法會自動執行，類（）會先執行type的__call__方法（呼叫類的__new__，__init__方法）
Foo 這個類是由SingletonType這個類建立的
'''
obj = Foo("hiayan")
# ============第三種方式實現單例模式=================
import threading
class SingletonType(type):
_instance_lock = threading.Lock()
def __call__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
with SingletonType._instance_lock:
if not hasattr(cls, "_instance"):
cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
return cls._instance
class Foo(metaclass=SingletonType):
def __init__(self,name):
self.name = name
obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)
複製程式碼5、裝飾器實現單例
def wrapper(cls):
instance = {}
def inner(*args,**kwargs):
if cls not in instance:
instance[cls] = cls(*args,**kwargs)
return instance[cls]
return inner
@wrapper
class Singleton(object):
def __init__(self,name,age):
self.name = name
self.age = age
obj1 = Singleton('haiyan',22)
obj2 = Singleton('xx',22)
print(obj1)
print(obj2)
複製程式碼單例應用 資料庫連線池
pool.py
import pymysql
import threading
from DBUtils.PooledDB import PooledDB
class SingletonDBPool(object):
_instance_lock = threading.Lock()
def __init__(self):
self.pool = PooledDB(
creator=pymysql, # 使用連結資料庫的模組
maxconnections=6, # 連線池允許的最大連線數，0和None表示不限制連線數
mincached=2, # 初始化時，連結池中至少建立的空閒的連結，0表示不建立
maxcached=5, # 連結池中最多閒置的連結，0和None不限制
maxshared=3,
# 連結池中最多共享的連結數量，0和None表示全部共享。PS: 無用，因為pymysql和MySQLdb等模組的 threadsafety都為1，所有值無論設定為多少，_maxcached永遠為0，所以永遠是所有連結都共享。
blocking=True, # 連線池中如果沒有可用連線後，是否阻塞等待。True，等待；False，不等待然後報錯
maxusage=None, # 一個連結最多被重複使用的次數，None表示無限制
setsession=[], # 開始會話前執行的命令列表。如：["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服務端，檢查是否服務可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
def __new__(cls, *args, **kwargs):
if not hasattr(SingletonDBPool, "_instance"):
with SingletonDBPool._instance_lock:
if not hasattr(SingletonDBPool, "_instance"):
SingletonDBPool._instance = object.__new__(cls, *args, **kwargs)
return SingletonDBPool._instance
def connect(self):
return self.pool.connection()
app.py
from pool import SingletonDBPool
def run():
pool = SingletonDBPool()
conn = pool.connect()
# xxxxxx
cursor = conn.cursor()
cursor.execute("select * from td where id=%s", [5, ])
result = cursor.fetchall() # 獲取資料
cursor.close()
conn.close()
if __name__ == '__main__':
run()
複製程式碼