设计模式之Singleton(2)

一、概述
在很多情况下，我们的系统只允许某个类有一个或指定个数的实例，如一般的应用系统往往有且仅有一个log文件操作类实例，或者，整个系统仅有一个等待事务队列等（注意：Singleton不是用来解决整个应用程序仅有一个实例这样的问题的），在这些情况下可以考虑使用Singleton模式。
Singleton（单件）模式用于保证一个类仅有一个实例，并提供一个访问该实例的全局访问点。（GoF: Ensure a class only has one instance, and provide a global point of access to it.）

二、结构
Singleton典型的结构如下图所示：

 
图1：Singleton模式的类图示意

三、应用
Singleton模式从概念上讲应该是所有模式中最简单的，它的目的很简单：限制我们创建实例的个数，Only one is permited。不过，该模式也可以扩展到允许指定数量个实例的情况。
一眼看去，Singleton似乎有些像全局对象。但是实际上，并不能用全局对象代替Singleton模式，这是因为：其一，有些编程语言例如Java、C#等，根本就不支持全局变量。其二，全局对象的方法并不能阻止人们将一个类实例化多次：除了类的全局实例外，开发人员仍然可以通过类的构造函数创建类的多个局部实例。而Singleton模式则通过从根本上控制类的创建，将“保证只有一个实例”这个任务交给了类本身，开发人员不可能再有其它途径得到类的多个实例。这一点是全局对象方法与Singleton模式的根本区别。

四、优缺点
Singleton模式是作为"全局变量"的替代品出现的，所以它具有全局变量的特点：全局可见；它也具有全局变量不具备的性质：同类型的对象实例只可能有一个。对于全局变量“贯穿应用程序的整个生命期”的特性，对于Singleton，视具体的实现方法，并不一定成立。

五、举例
实现该模式最简便的方法就是：采用static变量，并将类的构造函数、拷贝构造函数、赋值函数声明为private或者protected，同时提供public的实例创建/访问函数。
示例代码如下：

#include <assert.h>
#include <assert.h>
#include <iostream>
using namespace std;

class Singleton
{
public:
    static Singleton* Instance() {
        if (pInstance == NULL)
            pInstance = new Singleton();
        return pInstance;
    }
protected:
    Singleton() {}
private:
    static Singleton* pInstance;
    Singleton(const Singleton&) ;
    Singleton& operator=(const Singleton&) ;
};

Singleton* Singleton::pInstance = NULL;

int main()
{
    //Singleton instance;                    // Error
    //Singleton* pInstance = new Singleton;    // Error
    //Singleton instance = Singleton::Instance();    // Error
    Singleton* pInstance1 = Singleton::Instance(); // Good
    Singleton* pInstance2 = Singleton::Instance();

    cout.setf(ios::hex, ios::basefield);
    cout << "pInstance1 = " << pInstance1 << endl;
    cout << "pInstance2 = " << pInstance2 << endl;
    cout.setf(ios::dec, ios::basefield);
    assert(pInstance1 == pInstance2);
    
    return 0;
}

从结果我们可以我们两次获取到的是同一实例。上述实现方式只是众多实现方式中的一种，要将其改为多个实例的情况也十分简单。

但是，上述Singleton实现在多线程环境下不能正常工作，假定第一个线程完成：
if (pInstance == NULL)
检测后，CPU将控制权交给第二个（甚至是第三个、第四个...）线程，则最终我们可能获得n个而不是1个实例。以下实现方式同样无法保证线程安全：

static Singleton* Instance() {
    static Singleton _instance;
    return &_instance;
}

下面的代码模拟了该问题（由于涉及多线程问题，为了简化问题，以下代码用Java编写）：

class Singleton {
    private static Singleton singleton = null;
    
    protected Singleton() {
        try {
            Thread.currentThread().sleep(50);
        } catch(InterruptedException ex) {
        }
    }
    public static Singleton getInstance() {
        if(singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class SingletonTest {
    private static Singleton singleton = null;
    
    public static void main(String[] args) throws InterruptedException {
        // Both threads call Singleton.getInstance().
        Thread threadOne = new Thread(new SingletonTestRunnable()),
            threadTwo = new Thread(new SingletonTestRunnable());
        
        threadOne.start();
        threadTwo.start();
        
        threadOne.join();
        threadTwo.join();
    }
    
    private static class SingletonTestRunnable implements Runnable {
        public void run() {
            // Get a reference to the singleton.
            Singleton s = Singleton.getInstance();
            
            // Protect singleton member variable from multithreaded access.
            synchronized(SingletonTest.class) {
            if(singleton == null) // If local reference is null set it to the singleton
               singleton = s;
            }
            if (s == singleton)
                System.out.println("Yes.");
            else
                System.out.println("No.");
        }
    }
}

要保证结果的正确性，必须对获取Singleton实例的方法进行同步控制，为此，有人提出了double-checked locking的解决方案，相应的getInstance实现如下所示：

public static Singleton getInstance() {
    if(singleton == null) {
        synchronized(Singleton.class) {
            if(singleton == null) {
                singleton = new Singleton();
            }
        }
    }
    return singleton;
}

但据说，由于Java中，在变量singleton完成初始化前，即
singleton = new Singleton();
执行完毕前，sigleton的值可能是任意的，因此，若此时某个线程进入第一个if判断，则可能判断结果为false，从而返回一个无效的引用。因此，在Java中，唯一安全的方法是synchronized整个getInstance。

六、扩展
当系统中存在多个不同类型的Singleton时，可以考虑将Abstract Factory与Singleton模式结合，实现SingletonFactory，以下是一个SingletonFactory的例子：

import java.util.HashMap;

public class SingletonFactory {
    public static SingletonFactory singletonFactory = new SingletonFactory();
    private static HashMap map = new HashMap();
    
    protected SingletonFactory() {
        // Exists only to defeat instantiation.
    }
    public static synchronized Singleton getInstance(String classname) {
        if (classname == null) throw new IllegalArgumentException("Illegal classname");
        
        Singleton singleton = (Singleton)map.get(classname);
        
        if(singleton != null) {
            return singleton;
        }
        if (classname.equals("SingeltonSubclass1"))
            singleton = new SingletonSubclass1();    // SingletonSubclass1 derives from Singleton class or implements Singleton interface
        else if(classname.equals("SingeltonSubclass2"))
            singleton = new SingletonSubclass2();    // SingletonSubclass2 derives from Singleton or implements Singleton interface
        
        map.put(classname, singleton);
        return singleton;
    }
}

最后，需要注意的是，在C++中，单件对象的释放是个比较麻烦的事情，在上面的第一个示例中，由于没有释放单件对象，实际上是存在内存泄漏的，在释放单件对象的问题上，我们有以下几种选择：
1、在程序退出时由上层应用负责delete，比如在MFC程序中，在ExitInstance中逐一检查SingletonFactory的静态map对象所保存的Singleton；
2、在Singleton内部采用静态auto_ptr来封装Singleton对象，按此方法修改后的示例1如下所示：
#include <assert.h>
#include <iostream>
#include <memory>
using namespace std;

class Singleton
{
public:
    static Singleton* Instance() {
        if (instance.get() == NULL)
        {
            instance.reset(new Singleton());
        }
        return instance.get();
    }
protected:
    Singleton() {}
private:
    static auto_ptr<Singleton> instance;
    Singleton(const Singleton&) ;
    Singleton& operator=(const Singleton&) ;
};

auto_ptr<Singleton> Singleton::instance = auto_ptr<Singleton>(NULL);

int main()
{
    Singleton* pInstance1 = Singleton::Instance(); // Good
    Singleton* pInstance2 = Singleton::Instance();

    cout.setf(ios::hex, ios::basefield);
    cout << "pInstance1 = " << pInstance1 << endl;
    cout << "pInstance2 = " << pInstance2 << endl;
    cout.setf(ios::dec, ios::basefield);
    assert(pInstance1 == pInstance2);
    
    return 0;
}