单例类写法

单例类作用：只允许一次生成该类的对象！

#include "stdafx.h"
#include
using namespace std;

class MyCAS 
{
private:
    MyCAS(){}	//私有化构造函数，就不能用 MyCAS a; 这种语句成类对象了
private:  
    static MyCAS *m_instance;	//静态成员变量，用来判断是否已经生成了该类的对象
public:
    static MyCAS *GetInstance()     //只有调用此接口才能生成该类对象
    //声明为static后GetInstance就属于类了可以通过类名去调用而不需要先生成一个对象，因次m_instance也需要static
    {
        if (m_instance == NULL)     //若已此指针不为空直接返回该指针
        {
            m_instance = new MyCAS();    //用new创建的对象一定要delete
            static huishou hs;    //在这个对象作用域结束时会调huishou类的析构函数，在那里释放m_instance的内存
        }
        return m_instance;
    }
    class huishou
    {
    public:
        ~huishou() 
        {
            if (MyCAS::m_instance)    //若m_instance不空，就释放new出来的内存
            {
                delete MyCAS::m_instance;
                MyCAS::m_instance = NULL;
            }
        }
    };
    void func()    //测试单例类生成的对象的功能
    {
        cout << "test" << endl;
    }
};
MyCAS *MyCAS::m_instance = NULL;    //静态成员变量要赋初值

int main()
{
    MyCAS *p = MyCAS::GetInstance();    
    MyCAS *p2 = MyCAS::GetInstance();    //p和p2指向一个地址
    p->func();
    return 0;
}

多线程问题

若两个线程同时调用GetInstance，则两个线程可能都判断m_instance为空，然后生成了各自的对象，不满足要求；

一种方法是加锁，先生成一个互斥量resource_mutex，再在if前加：

std::unique_lock mymutex(resource_mutex);

这么写的问题是：当对象已经生成时，每次还是要先加锁再判断，但其实判断已经没有意义了，这个加锁只有创建时有用。

所以可以采用：双重锁定（双重检查）

if (m_instance == NULL)
{
    std::unique_lock mymutex(resource_mutex);
    if (m_instance == NULL)    //这里只有第一个拿到锁的线程才会判断为空而new，其他的即使走下来也return了
    {
        m_instance = new MyCAS();
        static huishou hs;
    }
}
return m_instance;