單例模式的四種方式
阿新 • • 發佈：2018-12-19
等待 ldb port result 手動 url 打印 文件 too
單例模式的四種方式
一、內容
- 保證一個類只有一個實例，並提供一個訪問它的全局訪問點
二、角色
- 單利
三、使用場景
- 當類只有一個實例而且客戶可以從一個眾所周知的訪問點訪問它時
- 比如：數據庫鏈接、Socket創建鏈接
四、優點
- 對唯一實例的受控訪問
- 單利相當於全局變量，但防止了命名空間被汙染
與單利模式功能相似的概念：全局變量、靜態變量（方法）
試問？為什麽用單例模式，不用全局變量呢？
答、全局變量可能會有名稱空間的幹擾，如果有重名的可能會被覆蓋
五、單例模式的四種實現方式
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)
六、單例模式的應用（會在數據庫連接池中用到單例模式），詳見以下示例操作
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()
額外補充的一種用裝飾器實現的單利模式
#
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)
單例模式的四種方式