由std::once_call 引发的单例模式的再次总结，基于C++11

一个偶然的机会，知道了std::once_call这个东西。

了解了下，std::once_call支持多线程情况下的某函数只执行一次。咦，这个不是恰好符合单例模式的多线程安全的困境吗？

单例模式，经常需要手写的经典面试题之一，很考验面试者的底子和水平。需要考虑的细节很多，其中多线程安全也是一个点。

本篇博文再次总结下单例模式，并且尽可能详细与完整，建议mark，面试前再回忆下（毕竟工作中直接有代码可以抄）。

单例模式，在本人看来是全局变量的一种C++封装。

常规的C语言中，经常会在文件开头定义一坨全局变量，有些还加上extern来支持变量的跨文件访问。确实难以维护，而且当项目庞大了，

有可能发生变量被偷偷修改的情况，导致一些奇怪难以排查的bug。

单例模式，则提供了一个供全局访问的类，包含了一系列全局访问的变量与方法，经过组织之后，变量的维护更清晰。一般以管理类居多。

带Manager类名的类往往都是单例模式实现的。

常规的单例模式的设计，仅能通过Instance方法（有些喜欢getInstance）类指针或者得到类实例（往往是引用，毕竟只有1个实例）。因此，

第一点要考虑的就是禁止构造函数、拷贝构造与赋值函数。如果需要释放资源，一般不允许调用delete 方法，最多对外提供Releace（有些喜欢Destroy）

方法来内部释放资源换。因此析构函数也要禁用。通用的单例模式的第一份装逼代码先写好。

#define SINGLETON_CTOR(x) \
     private:\
            x() = default;\
            x(const x&)=delete;\
            x& operator=(const x&)=delete;\
            ~x()=default;

因为不能通过构造函数得到类实例，因此类的Instance方法必须是static（即绑定到类对象设计本身，不属于类实例的方法）的。

有些人会区分饿汉式或者懒汉式的，面试时有时会紧张，写不全代码，先记住最简单又安全的实现。

class Singleton
{
    SINGLETON_CTOR(Singleton);
public:
    static Singleton& Instance()
    {
        static Singleton _instance;
        return _instance;
    }
};

静态局部变量会在第一次使用时初始化，多次调用被会编译器忽略，生命周期是程序的运行区间，并且是多线程安全的。

因为静态局部变量是分配在全局静态数据区（不是堆或者栈），内存一直都在（默认全部填0，但不占程序大小bss段）。

在我看来算属于饿汉式的，即程序运行期间就需要内存。

ok，我们看看其他变体实现。

class Singleton2
{
    SINGLETON_CTOR(Singleton2);
public:
    static Singleton2* Instance()
    {
        static Singleton2 _instance;
        return &_instance;
    }
};

有些人喜欢指针多一点。。。，就返回指针好了。

当然，既然如此简单，我们可以通过宏再加工一下，方便他人使用。

#define SINGLETON_INSTACNCE(x) SINGLETON_CTOR(x)\
    public:\
    static x* Instance()\
    {static x _instance; return &_instance;}

class SingletonOnceMore
{
    SINGLETON_INSTACNCE(SingletonOnceMore);
public:
    void fun(){}
};
class SingletonTwiceMore
{
    SINGLETON_INSTACNCE(SingletonTwiceMore);
public:
    void fun(){}
};

SingletonOnceMore::Instance()->fun();
SingletonTwiceMore::Instance()->fun();

class Singleton3
{
    SINGLETON_CTOR(Singleton3);
public:
    static Singleton3* Instance()
    {
        return &_instance;
    }

    static Singleton3 _instance;
};

Singleton3 Singleton3::_instance;  //这个得放cpp中，不然编译报错

静态成员变量也是ok的。

到这里为止，都是饿汉式的实现，接下来实现下懒汉式。

class SingletonNotGood
{
    SINGLETON_CTOR(SingletonNotGood);
public:
    static SingletonNotGood* Instance()
    {
        if (!_pInstance)
        {
            _pInstance = new SingletonNotGood;
        }
        return _pInstance;
    }
    static SingletonNotGood* _pInstance;
};

SingletonNotGood* SingletonNotGood::_pInstance;//这个得放cpp中，不然编译报错,静态成员默认赋null。

这是最简单的一种懒汉式实现。即看看指针存在否，不存在new一下。但存在一些问题。

1、内存无法正常释放

2、多线程不安全

尽管存在这些问题，但是如果你的管理类的生命周期与程序一样长，就可以不用考虑内存泄漏，毕竟操作系统会在程序退出时自动回收。（不过小心socket，可能导致不能正常关闭的问题 ）

然后如果没有多线程的困扰（比如很多管理类带有Init方法，在main函数的入口不远处先调用Init方法来实例化），那么这个简单的方法项目中还是可以用的。

当然，本文既然是总结，我们还得继续。一种简单的优化后如下：

#include <mutex>

class SingletonNotGood
{
    SINGLETON_CTOR(SingletonNotGood);
public:
    static SingletonNotGood* Instance()
    {
        std::lock_guard<std::mutex> lock_(m_cs);
        if (!_pInstance)
        {
            _pInstance = new SingletonNotGood;
        }
        return _pInstance;
    }
    static void Release()
    {
        std::lock_guard<std::mutex> lock_(m_cs);
        if (!_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }
private:
    static SingletonNotGood* _pInstance;
    static std::mutex m_cs;
};

SingletonNotGood* SingletonNotGood::_pInstance;//这个得放cpp中，不然编译报错,静态成员默认赋null。
std::mutex SingletonNotGood::m_cs;//这个得放cpp中，不然编译报错,

这里我们还可以使用 Double-Checked Locking Pattern (DCLP) 来减少锁的竞争机会，因为大部分情况下，_pInstance都是非空的。

static SingletonNotGood* Instance()
    {
        if (!_pInstance)  //读操作1
        {
            std::lock_guard<std::mutex> lock_(m_cs);  //只有空的情况下才加锁
            if (!_pInstance)
            {
                _pInstance = new SingletonNotGood;  //写操作2
            }
        }
        return _pInstance;
    }

尽管这个术语非常高上大，很多博客也会提及，但其实细究起来，它并不是线程安全的。

注意到_pInstance = new SingletonNotGood，是一个写操作，前面有一个无锁的读操作。当真正的写操作进行时，前面的读操作存在脏读情况。

_pInstance = new SingletonNotGood，表面上一个语句，展开后由

1、malloc 一块内存，地址复制到_pInstance

2、针对_pInstance 地址上调用placement new进行类的构造。

当多线程情况下，一个线程有可能进行了1之后，另外个线程进来后，判断非空，进行类对象的访问，导致crash。

如果这样写的项目没有遇到崩溃，大概率都是在main的某个地方提前实例化过了（如管理类很多有init方法，调用了就实例化了）。

这个崩溃的场景的概率真的很小 ，需要多线程恰好同时调用Instance，并且某一个线程执行了malloc后，分出时间片，另外个线程拿到了未构造的类实例进行操作。

但如果面试过程中，你能指出这一点，也是加分项吧。。。。

好的，优化后的单例looks good了，但还是有内存泄漏的风险，用户确实忘了Release了，有时，也不敢乱Release（因为你不知道还有其他人要弄否）。想要自动管理

内存释放？当然可以的。方法一：加一个垃圾收集类。

class SingletonNotGood
{
    SINGLETON_CTOR(SingletonNotGood);
public:
    static SingletonNotGood* Instance()
    {
        if (!_pInstance)  //读操作1
        {
            std::lock_guard<std::mutex> lock_(m_cs);  //只有空的情况下才加锁
            if (!_pInstance)
            {
                _pInstance = new SingletonNotGood;  //写操作2
            }
        }
        return _pInstance;
    }
    static void Release()
    {
        std::lock_guard<std::mutex> lock_(m_cs);
        if (!_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }

private:
    struct GarbageCollect
    {
        ~GarbageCollect()
        {
            if (!_pInstance)
            {
                delete _pInstance;
                _pInstance = nullptr;
            }
        }
    };

private:
    static SingletonNotGood* _pInstance;
    static std::mutex m_cs;
    static GarbageCollect gc;
};

SingletonNotGood* SingletonNotGood::_pInstance;//这个得放cpp中，不然编译报错,静态成员默认赋null。
std::mutex SingletonNotGood::m_cs;//这个得放cpp中，不然编译报错,
SingletonNotGood::GarbageCollect SingletonNotGood::gc;//这个得放cpp中，不然编译报错,

当然由于静态变量的空间是在全局内存区，其空间的释放是在程序结束才进行释放的。而在程序结束时，系统会自动回收该程序申请的空间。

gc的析构函数释放静态实例时，也是在程序结束时才会调用的。所以这里写的内存释放意义不大。当然对于那些在程序结束后不自动回收空间的系统，还是需要写空间回收的。

方法二，采用智能指针。

#include <memory>
class SingletonUsePtr
{
    SINGLETON_CTOR(SingletonUsePtr);
public:
    static SingletonUsePtr& Instance()
    {
        if (!_ptr)  //读操作1
        {
            std::lock_guard<std::mutex> lock_(m_cs);  //只有空的情况下才加锁
            if (!_ptr)
            {
                _ptr.reset(new SingletonUsePtr);
            }
        }
        return *_ptr;
    }
private:
    static std::unique_ptr<SingletonUsePtr> _ptr;
    static std::mutex m_cs;
};

std::unique_ptr<SingletonUsePtr> SingletonUsePtr::_ptr;//这个得放cpp中，不然编译报错,
std::mutex SingletonUsePtr::m_cs;//这个得放cpp中，不然编译报错,

这里使用shared_ptr也可以，不过shared_ptr占用的内存和内部复杂度（额外的有个block的概念用于存放引用计数等）稍大点。

推荐返回Singleton & 。用了智能指针就得放弃裸指针。

接下来，终于可以引出std::once_call再次优化以去掉额外的锁了。

class SingletonUsePtr2
{
    SINGLETON_CTOR(SingletonUsePtr2);
public:
    static SingletonUsePtr2& Instance()
    {
        static std::once_flag s_flag;
        std::call_once(s_flag, [&]() {
            _ptr.reset(new SingletonUsePtr2);
        });

        return *_ptr;
    }
private:
    static std::unique_ptr<SingletonUsePtr2> _ptr;
};

这个相对来说，是最简单的安全可靠的懒汉式实现了。有兴趣的也可以封装成宏，方便他人使用。

最后，再使用模板实现一份，采用curiously recurring template pattern，CRTP，不详细展开了，您坚持看到现在累了，我也写的累了 = =（主要原因）。

//采用模板再实现一次,
//使用方法 class YourSingleton: public SingletonBase<YourSingleton>
template<typename T>  //T 是子类
class SingletonBase
{
    SINGLETON_CTOR(SingletonBase);  //这个还是可以用的
public:
    static T&  Instance()
    {
        static T t;   //饿汉式
        return t;
    }
};

//再加上今天的学习的std::once_call实现懒汉式
template<typename T>  //T 是子类
class SingletonBaseLazy
{
    SINGLETON_CTOR(SingletonBaseLazy);  //这个还是可以用的
public:
    static T&  Instance()
    {
        static std::once_flag flag;
        std::call_once(flag, [&](){_ptr.reset(new T); });
        return *_ptr;
    }
    static std::unique_ptr<T> _ptr;
};
template<typename T>
std::unique_ptr<T> SingletonBaseLazy<T>::_ptr;

#include <iostream>
class YourSingleton : public SingletonBaseLazy < YourSingleton >
{
public:
    void test()
    {
        std::cout << "hello word" << std::endl;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    YourSingleton::Instance().test();
    YourSingleton::Instance().test();
    return ;
}

代码已上传 https://github.com/xuhuajie-NetEase/SingletonMode