Python單例模式

單例模式

""" 單例模式（Singleton Pattern）是一種常用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。 當你希望在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。 比如，某個服務器程序的配置信息存放在一個文件中，客戶端通過一個 AppConfig 的類來讀取配置文件的信息。 如果在程序運行期間，有很多地方都需要使用配置文件的內容，也就是說，很多地方都需要創建 AppConfig 對象的實例， 這就導致系統中存在多個 AppConfig 的實例對象，而這樣會嚴重浪費內存資源，尤其是在配置文件內容很多的情況下。 事實上，類似 AppConfig 這樣的類，我們希望在程序運行期間只存在一個實例對象。 """

1

2

3

4

5

6

7

8

9

當類只有一個實例而且客戶可以從一個眾所周知的訪問點訪問它時

比如：數據庫鏈接、Socket創建鏈接

''' 對唯一實例的受控訪問 單利相當于全局變量，但防止了命名空間被污染 與單利模式功能相似的概念：全局變量、靜態變量（方法） 那為什么用單例模式，不用全局變量呢？ 因為：全局變量可能會有名稱空間的干擾，如果有重名的可能會被覆蓋 '''

1

2

3

4

5

6

7

8

單例模式的實現

# 文件導入的形式 """ Python 的模塊就是天然的單例模式，因為模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時， 就會直接加載 .pyc 文件，而不會再次執行模塊代碼。因此，我們只需把相關的函數和數據定義在一個模塊中， 就可以獲得一個單例對象了。如果我們真的想要一個單例類，可以考慮這樣做： """

1

2

3

4

5

6

# 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)) # 35788560 from s1 import v as v2 print(v1,id(v2)) # 35788560 # 兩個的內存地址是一樣的 # 文件加載的時候，第一次導入后，再次導入時不會再重新加載。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

# ======================單例模式：無法支持多線程情況=============== 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() ''' # 打印結果內存地址不一樣，沒有實現單例 <__main__.Singleton object at 0x000001FC58CFC5F8> <__main__.Singleton object at 0x000001FC58B72470> <__main__.Singleton object at 0x000001FC58CFC6D8> <__main__.Singleton object at 0x000001FC58D03048> <__main__.Singleton object at 0x000001FC58D3FDD8> <__main__.Singleton object at 0x000001FC58D40208> <__main__.Singleton object at 0x000001FC58D407B8> <__main__.Singleton object at 0x000001FC58D401D0> <__main__.Singleton object at 0x000001FC58D4A3C8> <__main__.Singleton object at 0x000001FC58D4A2E8> '''

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

# ====================單例模式：支持多線程情況================、 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) ''' 打印結果： <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> <__main__.Singleton object at 0x000001938A81A320> '''

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

''' 通過上面例子，當我們實現單例時，為了保證線程安全需要在內部加入鎖 當我們實例化一個對象時，是先執行了類的__new__方法（我們沒寫時，默認調用object.__new__）， 實例化對象；然后再執行類的__init__方法，對這個對象進行初始化， 所有我們可以基于這個，實現單例模式 '''

1

2

3

4

5

6

7

# =============單線程下執行=============== 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) ''' 打印結果： <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> <__main__.Singleton object at 0x000001EBEF5E3E80> '''

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

""" 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) # 會不會打印？ # 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("jaychou") # ============第三種方式實現單例模式================= 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)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

在Python3中繼承type的就是元類

1

元類的示例：

1

# 方式一 class MyType(type): '''繼承type的就是元類''' def __init__(self,*args,**kwargs): print("MyType創建的對象",self) #Foo super(MyType,self).__init__(*args,**kwargs) def __call__(self, *args, **kwargs): obj = super(MyType,self).__call__(*args,**kwargs) print("類創建對象",self,obj) #Foo class Foo(object,metaclass=MyType): # 對象加括號會去執行__call__方法，__call__方法里面繼承了type的__call__方法 ，type的__call__方法里面會先執行__new__方法，再去執行__init__方法。 所以，Foo就是用type創建出來的 user = "haiyan" age = 18 obj = Foo()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

# 方式二 class MyType(type): def __init__(self, *args, **kwargs): print("ssss") super(MyType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): v = dir(cls) obj = super(MyType, cls).__call__(*args, **kwargs) return obj # 對象加括號就會去執行__call__方法 class Foo(MyType('Zcc', (object,), {})): # MyType('Zcc', (object,), {})相當于class Zcc(object):pass,也就是創建了一個Zcc的類 user = 'haiyan' age = 18 obj = Foo()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# 方式三 class MyType(type): def __init__(self, *args, **kwargs): print("ssss") super(MyType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): v = dir(cls) obj = super(MyType, cls).__call__(*args, **kwargs) return obj # 對象加括號就會去執行__call__方法 def with_metaclass(arg,base): print("類對象",MyType('Zcc', (base,), {})) return arg('Zcc', (base,), {}) # 返回一個類對象 class Foo(with_metaclass(MyType,object)): # MyType('Zcc', (object,), {})相當于class Zcc(object):pass,也就是創建了一個Zcc的類 user = 'haiyan' age = 18 obj = Foo()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

class ASD(type): pass qqq = ASD("qwe", (object,), {}) #用ASD這個元類創建了一個（qwe,并且繼承object類的）類 # class ASD(qwe): # pass obj = qqq() # 能創建類的是元類 # 能創建對象的是類 print(obj) # <__main__.qwe object at 0x00000000024FFBA8> print(obj.__class__) # print(obj.__class__.__class__) # print(obj.__class__.__class__.__class__) # print(obj.__class__.__class__.__class__.__class__) #

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

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) ------ 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('jaychou',22) obj2 = Singleton('eason',22) print(obj1) print(obj2)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

單例模式的應用

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()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

Python

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。