當前位置：首頁 > 编程语言 > python >内容正文

python

python单例_python 单例模式

發布時間：2025/3/12 python 25 豆豆

生活随笔收集整理的這篇文章主要介紹了 python单例_python 单例模式小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

單例模式

單例模式（Singleton Pattern）是一種常用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你希望在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。

比如數據庫連接讀取配置文件，如果在程序運行期間，有很多地方都需要連接數據庫，很多地方都需要創建數據庫對象的實例，這就導致系統中存在多個數據庫實例對象，而這樣會嚴重浪費內存資源，事實上，我們希望在程序運行期間只存在一個實例對象。

實現單例模式的5種方式

模塊方式

其實，Python 的模塊就是天然的單例模式，因為模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時，就會直接加載 .pyc 文件，而不會再次執行模塊代碼。

因此，我們只需把相關的函數和數據定義在一個模塊中，就可以獲得一個單例對象了。如果我們真的想要一個單例類，可以考慮這樣做：

mysingleton.py

class Singleton(object):

def foo(self):

pass

single = Singleton()

將上面的代碼保存在文件 mysingleton.py 中，要使用時，直接在其他文件中導入此文件中的對象，這個對象即是單例模式的對象

from demo.my_singleton import single

single.foo()

使用裝飾器

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

def __init__(self, x=0):

self.x = x

a1 = A(2)

a2 = A(3)

print(id(a1), id(a2))

使用類

class Singleton(object):

__instance = None

def __init__(self, x):

self.x = x

print(x)

@classmethod

def my_singleton(cls, *args, **kwargs):

if not cls.__instance:

cls.__instance = cls(*args, **kwargs)

return cls.__instance

如果遇到多線程會出現問題

import threading

class Singleton(object):

__instance = None

def __init__(self, x):

self.x = x

import time

time.sleep(1) # 加入干擾元素，造成多線程出現問題

@classmethod

def my_singleton(cls, *args, **kwargs):

if not cls.__instance:

cls.__instance = cls(*args, **kwargs)

return cls.__instance

import threading

def task(arg):

obj = Singleton.my_singleton(arg)

print(obj)

for i in range(10):

t = threading.Thread(target=task, args=(i,))

t.start()

-------------------

<__main__.Singleton object at 0x00000000025D76D8>

<__main__.Singleton object at 0x000000000259FF28>

<__main__.Singleton object at 0x000000001234A208>

<__main__.Singleton object at 0x000000001234A1D0>

<__main__.Singleton object at 0x000000001234A438>

<__main__.Singleton object at 0x000000001234A630>

<__main__.Singleton object at 0x000000001234A828>

<__main__.Singleton object at 0x000000001234A978>

<__main__.Singleton object at 0x000000001234A748>

<__main__.Singleton object at 0x000000001234AAC8>

解決方法：加鎖！未加鎖部分并發執行,加鎖部分串行執行,速度降低,但是保證了數據安全

import threading

class Singleton(object):

__instance = None

__instance_lock = threading.Lock()

def __init__(self, x):

self.x = x

import time

time.sleep(1) # 加入干擾元素，造成多線程出現問題

@classmethod

def my_singleton(cls, *args, **kwargs):

with cls.__instance_lock: # 加鎖

if not cls.__instance:

cls.__instance = cls(*args, **kwargs)

return cls.__instance

import threading

def task(arg):

obj = Singleton.my_singleton(arg)

print(obj)

for i in range(10):

t = threading.Thread(target=task, args=(i,))

t.start()

----------------------

<__main__.Singleton object at 0x000000000259FF28>

基于__new__方法實現（推薦使用）

當我們實例化一個對象時，是先執行了類的__new__方法（我們沒寫時，默認調用object.__new__），實例化對象；然后再執行類的__init__方法，對這個對象進行初始化。

import threading

class Singleton(object):

_instance_lock = threading.Lock()

def __init__(self, x):

self.x = x

import time

time.sleep(1) # 加入干擾元素，造成多線程出現問題

def __new__(cls, *args, **kwargs):

if not hasattr(cls, '_instance'):

with cls._instance_lock: # 加鎖

cls._instance = super(Singleton, cls).__new__(cls)

return cls._instance

import threading

def task(arg):

obj = Singleton(arg)

print(obj)

for i in range(10):

t = threading.Thread(target=task, args=(i,))

t.start()

----------------

<__main__.Singleton object at 0x000000000257FF60>

基于metaclass方式實現

1.類由type創建，創建類時，type的__init__方法自動執行，類() 執行type的 __call__方法(類的__new__方法,類的__init__方法)

2.對象由類創建，創建對象時，類的__init__方法自動執行，對象()執行類的 __call__ 方法

實現單例

import threading

class SingletonType(type):

_instance_lock = threading.Lock()

def __init__(self,class_name,class_bases,class_dic):

super(SingletonType, self).__init__(class_name,class_bases,class_dic)

def __call__(cls, *args, **kwargs):

if not hasattr(cls, '_instance'):

with cls._instance_lock: # 加鎖

cls._instance = super(SingletonType, cls).__call__(*args, **kwargs)

return cls._instance

class my_singlton(metaclass=SingletonType):

def __init__(self,x):

self.x = x

import threading

def task(arg):

obj = my_singlton(arg)

print(obj)

for i in range(10):

t = threading.Thread(target=task, args=(i,))

t.start()

--------------------------

<__main__.my_singlton object at 0x00000000025CFF60>

單例模式使用

import threading

class SingletonDB(object):

_instance_lock = threading.Lock()

def __init__(self,host='127.0.0.1',

port=3306,

user='root',

password='root',

database='testdb',

charset='utf8'):

self.host = host

self.port = port

self.password = password

self.user = user

self.database = database

self.charset = charset

def __new__(cls, *args, **kwargs):

if not hasattr(SingletonDB, "_instance"):

with SingletonDB._instance_lock:

if not hasattr(SingletonDB, "_instance"):

SingletonDB._instance = object.__new__(cls, *args, **kwargs)

return SingletonDB._instance

def connect(self):

print('connect db')

db1 = SingletonDB()

db2 = SingletonDB()

print(db1,db2)

db1.connect()

db2.connect()

----------------

<__main__.SingletonDB object at 0x00000000025E76D8> <__main__.SingletonDB object at 0x00000000025E76D8>

connect db

總結

以上是生活随笔為你收集整理的python单例_python 单例模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：云服务器如何链接本地打印机_利用File
下一篇： python曲线拟合预测_用python