单例模式--Python

单例模式

单例模式是一个很有用的避免冲突的设计模式，相当于把所有同样资源的调用都交给了一个资源代理。该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

• 使用装饰器（decorator）

• 使用元类（metaclass）

• 使用模块

• 使用 __new__

在 Python 中，我们可以用多种方法来实现单例模式：

装饰器

所有资源资源调用者都是同一个对象，我首先想到的就是装饰器，可以很方便的给不同的对象增添相同的功能。

Python 官方 wiki给出了一个非常优雅的实现：

def singleton(cls):
    instance = cls()
    instance.__call__ = lambda: instance
    return instance

# Sample use

@singleton
class Highlander:
    x = 100
    # Of course you can have any attributes or methods you like.


highlander = Highlander()
another_highlander = Highlander()
assert id(highlander) == id(another_highlander)

上面的代码定义了一个 singleton 装饰器，覆盖了类的 __call__ 方法，该方法会在类创建的时候创建一个类的实例，并在之后类每次的实例化时总是返回这个实例对象。

当然，如果你希望只在需要的时候创建类的实例对象也有别的方法：

def singleton(cls, *args, **kw):
    instances = {}
    def _singleton():
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return _singleton

@singleton
class MyClass(object):
    a = 1
    def __init__(self, x=0):
        self.x = x

one = MyClass()
two = MyClass()

assert id(one) == id(two)

上面的代码中实现了这样一个装饰器：装饰器函数创建的时候会创建一个 instances 字典，该字典用于保存被装饰器修改过的类的实例，在类初始化的时候首先判断是否存在其实例，如果存在则直接返回，否则创建一个新的实例保存到 instances 字典中，并返回该实例。（这段代码出自cnblogs）

metaclass

我自己对于不是很喜欢装饰器的实现，因为从语言逻辑上来看，我需要的是一个有单例特性的类而不是为类添加单例限制。于是我又找到了基于 metaclass 的实现：

class Singleton(type):
    def __init__(cls, name, bases, dict):
        super(Singleton, cls).__init__(name, bases, dict)
        cls._instance = None
    def __call__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__call__(*args, **kw)
        return cls._instance

class MyClass(object):
    __metaclass__ = Singleton

one = MyClass()
two = MyClass()

上面的代码在类的第一次实例之后将这个个实例作为其类变量保存，在之后调用类的构造函数的时候都直接返回这个实例对象。

这个解决方案强化了类与其单例之间的内聚性。

使用模块

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成.pyc 文件，当第二次导入时，就会直接加载.pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

class My_Singleton(object):
    def foo(self):
        pass
my_singleton = My_Singleton()

from mysingleton import my_singleton
my_singleton.foo()

将上面的代码保存在文件 mysingleton.py 中，然后这样使用：

使用__new__

为了使类只能出现一个实例，我们可以使用 __new__ 来控制实例的创建过程，代码如下：

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  
class MyClass(Singleton):  
    a = 1

执行情况如下：在上面的代码中，我们将类的实例和一个类变量_instance 关联起来，如果 cls._instance 为 None 则创建实例，否则直接返回cls._instance。

>>> one = MyClass()
>>> two = MyClass()
>>> one == two
True
>>> one is two
True
>>> id(one), id(two)
(4303862608, 4303862608)

我们知道，装饰器（decorator）可以动态地修改一个类或函数的功能。这里，我们也可以使用装饰器来装饰某个类，使其只能生成一个实例，代码如下：使用装饰器

from functools import wraps
def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance
@singleton
class MyClass(object):
    a = 1

使用 metaclass在上面，我们定义了一个装饰器 singleton，它返回了一个内部函数getinstance，该函数会判断某个类是否在字典instances 中，如果不存在，则会将cls 作为 key，cls(*args, **kw) 作为 value 存到instances 中，否则，直接返回instances[cls]。

元类（metaclass）可以控制类的创建过程，它主要做三件事：

• 拦截类的创建

• 修改类的定义

• 返回修改后的类

使用元类实现单例模式的代码如下：

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
# Python2
class MyClass(object):
    __metaclass__ = Singleton
# Python3
# class MyClass(metaclass=Singleton):
#    pass

Python 的模块是天然的单例模式，这在大部分情况下应该是够用的，当然，我们也可以使用装饰器、元类等方法小结

__init__是实例级别的算法，__new__是类级别的算法 对类实例化的时候，先执行__new__,后执行__init__.