python中的单例模式实现

什么是单例模式

单例模式是一种经常使用的设计模式，使用该模式创建的类对象在整个系统中只有一个。在python中，使用id(实例名)可以看到多次创建该类的对象的id是相同的

什么时候适合使用单例模式

简而言之一句话，需要节省内存，加快对象访问速度以及对象需要被公用的场合

单例模式使用场景

1. 系统中配置文件的管理
2. 网站中的计数器
3. 应用程序的日志应用
4. 等等。。。

python中单例模式的实现

1. 通过模块实现单例模式（最简单的实现方式）

原理：python的模块其实是一个非常好的自带单例模式，python的模块在导入时会生成.pyc文件，在后面再次导入该模块时，会加载.pyc文件

代码示例：singleton.py

# -*- coding: utf-8 -*-

class Singleton(object):
	pass

s = Singleton()

上述文件中就存在了一个Singleton类的实例s，在使用时，通过from singleton import s导入这个实例，就可以获得这个使用这个单例，同时它也是一个单例模式的对象

2. 通过改写__new__方法实现（推荐使用该方法）

原理：在python的类创建对象的过程中，先通过__new__方法实例化一个对象（PS：在没有自己定义该方法时会默认调用object.new），然后才执行__init__方法对实例化的对象进行各项初始化复制操作。

代码示例：

# -*- coding: utf-8 -*-
import threading


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

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._lock:    # 加锁防止多线程环境中两个线程同时判断到上一行代码为True，同时创建该类的实例
                if not hasattr(Singleton, "_instance"):
                	# 调用object类的__new__方法
                    Singleton._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return Singleton._instance


def test(number):
    s = Singleton()
    print str(number) + ": " + str(id(s))


for i in range(10):
    t = threading.Thread(target=test, args=(i, ))
    t.start()

上述程序运行结果如下：

3. 基于指定metaclass实现

原理：这个解释起来源远流长，可以针对元类单独写一篇博客了，这里就简单说明一下。类其实也是一个对象，创建类的类就是元类，大致可以理解为：MyClass = MetaClass()，MyObject = MyClass()，其中MetaClass就是一个元类，是创建MyClass这个实例(对于MyObject来说它又是一个类，注意区别理解)的类。在python中默认的元类是一个强大的函数type。

代码示例：

# -*- coding: utf-8 -*-
import threading


# 注意这里继承了type不是object
class SingletonMeta(type):
    _lock = threading.Lock()

    def __init__(self, *args, **kwargs):
        super(SingletonMeta, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonMeta._lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonMeta, cls).__call__(*args, **kwargs)
        return cls._instance


class Singleton:
    __metaclass__ = SingletonMeta    # 指定元类

    def __init__(self, x):
        self.x = x


def test(number):
    s = Singleton(number)
    print str(number) + ": " + str(id(s))


for i in range(10):
    t = threading.Thread(target=test, args=(i, ))
    t.start()

结果如下所示：

4. 使用装饰器

相关知识：装饰器的使用方法类似java中的注解，大概形式如下：

def log(func):
   def wrapper(*args, **kwargs):
       return func(*args, **kwargs)
   return log


@log
def f():
   pass

实际上述f函数执行过程变为f=log(f), f()

代码示例：

# -*- coding: utf-8 -*-
import threading


def Singleton(cls):
    _instance = {}

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


@Singleton
class A(object):
    a = 1

    def __init__(self, x=0):
        self.x = x


a1 = A(2)
a2 = A(3)
print a1 == a2

5. 使用类

原理：使用类成员，类成员是该类所有实例共有的属性

代码示例：

# -*- coding: utf-8 -*-
import threading


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

    @classmethod
    def generate(cls, *args, **kwargs):
        with Singleton._lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance


def test(number):
    s = Singleton.generate()
    print str(number) + ": " + str(id(s))


for i in range(10):
    t = threading.Thread(target=test, args=(i, ))
    t.start()

执行结果如下：