python单例模式

python实现单例模式几种方式。

①文件导入的形式：

python的模块就是天然的单例模式，因为模块在第一次导入的时候，会生成.pyc文件，当第二次导入的时候，就会直接加载.pyc文件，而不是再次执行模块代码。
将Foo类在某个文件（test1.py）中实例化，赋值给某个变量v。在其他文件如test2.py中引入该实例，多次引用打印其内存地址，发现是一样。

#test1.py

class Foo(object):
    def test(self):
        print("123")

v = Foo()

#test2.py
from test1 import v as v1
print(v1, id(v1))  

from test1 import v as v2
print(v2,id(v2)) 




output:
(<test2.Foo object at 0x00000000025D3C50>, 39664720L)
(<test2.Foo object at 0x00000000025D3C50>, 39664720L)

在其他文件导入该实例，则多次导入的实例为同一个。
文件加载的时候，第一次导入后，再次导入不会再重新加载。

②基于__new__来实现单例。
 一个对象的实例化过程是先执行类的__new__方法，如果我们没有写,默认会调用object的__new__方法，返回一个实例化对象,然后再调用__init__方法，对这个对象进行初始化，我们可以根据这个实现单例。

思路：在一个类的__new__方法中先判断是不是存在实例,如果存在实例,就直接返回,如果不存在实例就创建。

 

# encoding:utf-8
import threading


class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self, *args, **kwargs):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            with Singleton._instance_lock:
                if not hasattr(cls, '_instance'):
                    Singleton._instance = object.__new__(cls)

        return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1, obj2)

#output
(<__main__.Singleton object at 0x0000000002DF4CF8>, <__main__.Singleton object at 0x0000000002DF4CF8>)

执行上面代码，可以发现obj1和obj2内存地址一样，表示为同一实例。

③使用装饰器。见文档。

在python中，一切皆对象，那么函数也是对象，函数是对象，因此对象就可以赋值给一个变量，可以在其他函数中定义，可以返回另外一个函数，函数可以作为参数传递。装饰器就是把其他函数作为参数的函数，在函数中，装饰器在运行中定义函数:包装。这个函数将被包装在原始函数的外面，所以可以在原始函数之前和之后执行其他代码。
思路：

装饰器里面的外部变量定义一个字典，里面存放这个类的实例。当第一次创建的时候，就将这个实例保存到这个字典中。然后以后每次创建对象的时候，都去这个字段中判断一下，如果已经被实例化，就直接取这个实例对象，如果不存在就保存在字典中。
 

from functools import wraps


def Singleton(cls):
    _instance = {}

    @wraps(cls)
    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]

    return _singleton


@Singleton
class Settings():
    """Docstring"""

    def __init__(self):
        self.a = "xxx"
        self.b = "xxx"


settings = Settings()
s1 = Settings()
s2 = Settings()
print(s1,s2)

#output
(<__main__.Settings instance at 0x000000000348B108>, <__main__.Settings instance at 0x000000000348B108>)

执行上面代码，可以发现s1和s2内存地址一样，表示为同一实例。

④使用类。

思路：调用类的类方法（classmethod）,这样有一个弊端就是在使用类创建的时候,并不是单例.也就是说在创建类的时候一定要用类里面规定的方法创建。比如下面的get_instance方法。

# encoding:utf-8
import time
import threading


class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self, *args, **kwargs):
        time.sleep(1)

    @classmethod
    def get_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


s1 = Singleton.get_instance()
s2 = Singleton.get_instance()

print(s1, s2)

这种方法在项目中使用的比较多，但是这种方法不如__new__来的简单。

还有一种方式是使用元类，项目中用的较少，就不介绍了。后面有时间了再写....