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>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__main__.Singleton object at 0x000000000259FF28>
<__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>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__main__.Singleton object at 0x000000000257FF60>
<__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>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__main__.my_singlton object at 0x00000000025CFF60>
<__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
connect db