单例模式（经典）

一 、定义

众多设计模式中，单例模式是一种比较常见模式。本文以一个C++开发者的角度分析单例模式的几种经典实现。

GOF定义单例模式需满足以下两个条件：

1、保证一个类只创建一个实例。

2、提供对实例的全局访问点。

二、应用场景

日志类、配置类、管理类、共享资源类

三、单例的几种实现

3.1 lazy singleton

//头文件中
class Singleton
{
public:
    static Singleton& Instance()
    {
        if (instance_ == NULL)
        {
            instance_ = new Singleton;
        }
        return *instance_;
    }
private:
    Singleton()；
        ~Singleton()；
        Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
private:
    static Singleton* instance_;
};
//实现文件中
Singleton* Singleton::instance_ = 0;

优点：这里Instance()返回的实例的引用而不是指针，如果返回的是指针可能会有被外部调用者delete掉的隐患，所以这里返回引用会更加保险一些。并且直到Instance()被访问，才会生成实例，这种特性被称为延迟初始化（Lazy initialization），这在一些初始化时消耗较大的情况有很大优势。


缺点：Lazy Singleton不是线程安全的，比如现在有线程A和线程B，都通过instance_ == NULL的判断，那么线程A和B都会创建新实例。单例模式保证生成唯一实例的规则被打破了。

3.2 Eager Singleton

这种实现在程序开始(静态属性instance初始化)的时就完成了实例的创建。这正好和上述的Lazy Singleton相反。

//头文件中
class Singleton
{
public:
    static Singleton& Instance()
    {
        return instance;
    }
private:
    Singleton();
    ~Singleton();
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
private:
    static Singleton instance;
}
//实现文件中
Singleton Singleton::instance;

由于在main函数之前初始化，所以没有线程安全的问题，但是潜在问题在于no - local static对象（函数外的static对象）在不同编译单元（可理解为cpp文件和其包含的头文件）中的初始化顺序是未定义的。如果在初始化完成之前调用 Instance()方法会返回一个未定义的实例。


2.3 Meyers Singleton

Scott Meyers在《Effective C++》（Item 04）中的提出另一种更优雅的单例模式实现，使用local static对象（函数内的static对象）。当第一次访问Instance()方法时才创建实例。

class Singleton
{
public:
    static Singleton& Instance()
    {
        static Singleton instance；
            return instance；
    }
private:
    Singleton()；
        ~Singleton()；
        Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
};
C++0x之后是该实现线程安全的，有兴趣可以读相关的标准草案（section 6.7）编译器支持程度不一定, 但是G++4.0及以上是支持的。


2.4 双检测锁模式（Double - Checked Locking Pattern）

Lazy Singleton的一种线程安全改造是在Instance()中每次判断是否为NULL前加锁，但是加锁是很慢的。
而实际上只有第一次实例创建的时候才需要加锁。双检测锁模式被提出来，改造之后大致是这样

static Singleton& Instance()
{
    if (instance_ == NULL)
    {
        Lock lock; //基于作用域的加锁，超出作用域，自动调用析构函数解锁
        if (instance_ == NULL)
        {
            instance_ = new Singleton;
        }
    }
    return *instance_;
}
既然只需要在第一次初始化的时候加锁，那么在这之前判断一下实例有没有被创建就可以了，所以多在加锁之前多加一层判断，需要判断两次所有叫Double - Checked。理论上问题解决了，但是在实践中有很多坑，如指令重排、多核处理器等问题让DCLP实现起来比较复杂比如需要使用内存屏障，详细的分析可以阅读这篇论文。


在C++11中有全新的内存模型和原子库，可以很方便的用来实现DCLP。这里不展开。有兴趣可以阅读这篇文章《Double - Checked Locking is Fixed In C++11》。
pthread_once在多线程编程环境下，尽管pthread_once()调用会出现在多个线程中，init_routine()函数仅执行一次，pthread_once是很适合用来实现线程安全单例。


template<typename T>
class Singleton : boost::noncopyable
{
public:
    static T& instance()
    {
        pthread_once(&ponce_, &Singleton::init);
        return *value_;
    }


    static void init()
    {
        value_ = new T();
    }
private:
    static pthread_once_t ponce_;
    static T* value_;
};
template<typename T>
pthread_once_t Singleton<T>::ponce_ = PTHREAD_ONCE_INIT;


template<typename T>
T* Singleton<T>::value_ = NULL;
这里的boost::noncopyable的作用是把构造函数, 赋值函数, 析构函数, 复制构造函数声明为私有或者保护。


总结
单例模式的实现方法很多，要写一个完美的实现很难代码也会很复杂。但是掌握基础的实现还是很必要的，然后在实际应用中不断地去优化和探索。除了线程安全，一些场景下还有需要考虑资源释放，生命周期等相关问题，可以参见《Modern C++ Design》中对Singleton的讨论