设计模式

单例模式

一个类仅有一个实例，并提供一个全局访问点，该实例被所有程序模块共享。

Java基于ClassLoader机制确保类只被实例化1次。多线程安全，没有加锁，类加载时初始化，浪费内存。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

Java基于枚举类的常量确保类只被实例化1次（实际上枚举常量在内部都转化为枚举类的实例）。多线程安全，支持序列化机制，非Lazy初始化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

Python利用类地址和类变量的全局唯一性确保类只被实例化1次（实例变量不是全局唯一的）。

Python类(class)通过__new__()创造实例(instance)，继承并修改__new__()方法，检验类变量。

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):  # 类实例化时的传参可以接收到，默认参数接收不到
        if cls._instance is None:
            cls._instance = object.__new__(cls)
        return cls._instance
    def __init__(self):
        pass

single1 = Singleton()
single2 = Singleton()
print(id(single1) == id(single2))

使用Python函数装饰器，检验类变量。

def singleton(cls):
    _instance = {}

    def func():
        if cls not in _instance:
            _instance[cls] = cls()
        return _instance[cls]
    return func
    
@singleton
class Cls(object):
    def __init__(self):
        pass

cls1 = Cls()
cls2 = Cls()
print(id(cls1) == id(cls2))

使用Python函数装饰器，检验类变量。

class Singleton(object):
    def __init__(self, cls):
        self._cls = cls
        self._instance = {}
    def __call__(self):
        if self._cls not in self._instance:
            self._instance[self._cls] = self._cls()
        return self._instance[self._cls]

@Singleton
class Cls2(object):
    def __init__(self):
        pass

cls1 = Cls2()
cls2 = Cls2()
print(id(cls1) == id(cls2))

C++中static对象的初始化

non-local static对象（函数外）。初始化发生在main函数执行之前，也即main函数之前的单线程启动阶段，所以不存在线程安全问题。但C++没有规定多个non-local static 对象的初始化顺序，尤其是来自多个编译单元的non-local static对象，他们的初始化顺序是随机的。

local static 对象（函数内）。初始化发生在控制流第一次执行到该对象的初始化语句时。多个线程的控制流可能同时到达其初始化语句。C++11之前，在多线程环境下local static对象的初始化并不是线程安全的。C++11规定，在一个线程开始local static 对象的初始化后到完成初始化前，其他线程执行到这个local static对象的初始化语句就会等待，直到该local static 对象初始化完成。

class Singleton
{
private:
    Singleton() { };
    ~Singleton() { };
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
public:
    static Singleton& getInstance() 
        {
        static Singleton instance;
        return instance;
    }
};