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