每次例項化出來乙個物件, 就會在記憶體中重新分配一塊空間, 而今天介紹的單例模式, 就是為了解決上述問題, 使得由乙個類物件所例項化出來的全部物件都指向同一塊記憶體空間
class a:
pass
a = a()
print('a物件所在的記憶體位址是 %d， a類所在的記憶體位址是 %d' % (id(a), id(a)))
b = a()
print('b物件所在的記憶體位址是 %d, a類所在的記憶體位址是 %d' % (id(b), id(a)))
c = a()
print('c物件所在的記憶體位址是 %d, a類所在的記憶體位址是 %d' % (id(c), id(a)))
a物件所在的記憶體位址是 4461629568， a類所在的記憶體位址是 140541033538936
b物件所在的記憶體位址是 4461630744, a類所在的記憶體位址是 140541033538936
c物件所在的記憶體位址是 4461630632, a類所在的記憶體位址是 140541033538936
因此, 我們可以重寫__new__()這個方法, 讓他在第一次例項化乙個物件之後, 分配一塊位址, 在此後的所有例項化的其他物件時, 都不再分配新的位址, 而繼續使用第乙個物件所被分配的位址, 因此, 我們可以在類物件裡, 定義乙個類屬性, 初始值設為none, 如果這個值是none就呼叫父類的__new__()方法, 為其分配位址, 並返回這個位址(__new__方法一定要返回乙個位址)
class b(object):
instant = none
flag = true
def __new__(cls, *args, **kwargs):
if cls.instant is none:
cls.instant = super().__new__(cls)
return cls.instant
def __init__(self):
if not b.flag:
return
self.name = '張三'
b.flag = false
print('b被初始化了')
d = b()
print('d物件所在的記憶體位址是 %d, b類所在的記憶體位址是 %d' % (id(d), id(b)))
e = b()
print('e物件所在的記憶體位址是 %d, b類所在的記憶體位址是 %d' % (id(e), id(b)))
f = b()
print('f物件所在的記憶體位址是 %d, b類所在的記憶體位址是 %d' % (id(f), id(b)))
b被初始化了
d物件所在的記憶體位址是 4463084656, b類所在的記憶體位址是 140281435406488
e物件所在的記憶體位址是 4463084656, b類所在的記憶體位址是 140281435406488
f物件所在的記憶體位址是 4463084656, b類所在的記憶體位址是 140281435406488
該模式的主要目的是確保某乙個類只有乙個例項存在。當你希望在整個系統中，某個類只能出現乙個例項時，單例物件就能派上用場
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"):
singleton._instance = object.__new__(cls)
return singleton._instance
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()
def singleton(cls):
_instance = {}
def _singleton(*args, **kargs):
if cls not in _instance:
_instance[cls] = cls(*args, **kargs)
return _instance[cls]
return _singleton
@singleton
class a(object):
a = 1
def __init__(self, x=0):
self.x = x
a1 = a(2)
a2 = a(3)
print(id(a1))
print(id(a2))
4466709616
4466709616
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(id(obj1))
print(id(obj2))
4316770376
4316770376
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...