单例模式是23种面向对象的设计模式之一。在实际应用中，涉及到配置或资源管理的对象，都应该考虑单例模式。广义上讲，只要能够保证只执行一次类的实例化过程，就能实现单例模式。如果某段代码确实只会执行一次，那么就是一个天然的单例模式，比如python里的模块导入。而有的时候，初始化对象的函数可能要执行多次，这时就需要对类的实例化进行拦截。单例模式最基本的问题，是判断是否类已经实例化，这就需要用一个变量，来判断，比如锁，全局变量，类变量(Python), 闭包（Python）等等。
1. Staticmethod/Classmethod
# 用类方法 类属性来实现 典型的tarnado模块 IOLoop
class IOLoop(object):
'''
some other code ...
'''
@staticmethod # 类方法装饰器
def instance():
"""Returns a global IOLoop instance.
Most single-threaded applications have a single, global IOLoop.
Use this method instead of passing around IOLoop instances
throughout your code.
A common pattern for classes that depend on IOLoops is to use
a default argument to enable programs with multiple IOLoops
but not require the argument for simpler applications::
class MyClass(object):
def __init__(self, io_loop=None):
self.io_loop = io_loop or IOLoop.instance()
"""
if not hasattr(IOLoop, "_instance"):
with IOLoop._instance_lock:
if not hasattr(IOLoop, "_instance"):
# New instance after double check
IOLoop._instance = IOLoop()
return IOLoop._instance
@staticmethod
def initialized():
"""Returns true if the singleton instance has been created."""
return hasattr(IOLoop, "_instance")
def install(self):
"""Installs this IOloop object as the singleton instance.
This is normally not necessary as `instance()` will create
an IOLoop on demand, but you may want to call `install` to use
a custom subclass of IOLoop.
"""
assert not IOLoop.initialized()
IOLoop._instance = self
2. __new__
# 使用__new__
class singleton1(object):
def __new__(cls, *args, **kwargs): #new拦截类的实例化
if not hasattr(cls, '_instance'):
print 'create instance here'
cls._instance = super(singleton1, cls).__new__(cls, *args, **kwargs)
return cls._instance
print singleton1()
print singleton1()
create instance here
<__main__.singleton1 object at 0x7f2ad40dacd0>
<__main__.singleton1 object at 0x7f2ad40dacd0>
关于new: new是用来创建对象的。拦截类的实例化，修改对象的属性，返回这个对象。new之后对象才存在，init只是修改类的属性
3.元类
# 使用metaclass， 生成类的类
class meta_single(type):
_instance = {}
# 这里要用__call__， 而不是__new__
def __call__(cls, *args, **kwargs):
if cls not in cls._instance:
print 'create instance here'
cls._instance[cls] = super(meta_single, cls).__call__(*args, **kwargs)
return cls._instance[cls]
class singleton2(object):
# __metaclass__拦截类的创建,而不是拦截实例化
__metaclass__ = meta_single # 在这里， 元类中的__new__方法和__init__方法其实已经被执行了
print singleton2()
print singleton2()
print isinstance(singleton2, meta_single)
print issubclass(singleton2, meta_single)
create instance here
<__main__.singleton2 object at 0x7f2ad4084c50>
<__main__.singleton2 object at 0x7f2ad4084c50>
True
False
关于元类：元类是用来生成类的(注意不是类的实例)， 元类回拦截类的创建，修改类的属性，并返回这个类。可以理解为singleton2是meta_single的一个对象。 python3的语法略有不同。
4.装饰器 + 闭包
# 使用装饰器
from functools import wraps
def dec_single(cls):
instances = {} # 闭包
@wraps(cls)
def getinstance(*args, **kw):
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return getinstance
@dec_single
class singleton3(object):
pass
print singleton3()
print singleton3()
<__main__.singleton3 object at 0x7f2accefb4d0>
<__main__.singleton3 object at 0x7f2accefb4d0>
这里用到了闭包，要注意一下
需要注意：
- 其实1,2,3都是利用了类属性来记录类是否实例化过。原理上是一样的。
- 以上都不是线程安全的
