单例模式（懒汉单例和饿汉单例）

转载于：http://www.manongjc.com/article/53899.html

==单例模式就是指一个类在整个程序中只有一个实例。==确保一些不需要重复创建的类创建多余的实例。特别是某些工具类，在所有地方使用该类都只需要一个实例。
基本思路就是在单例类内部创建一个静态的自身对象，并自己管理自己。
下面代码用锤子Hammer来表示这个工具，简单的实现如下

1、懒汉模式

懒汉模式就是指铁匠是个懒汉，这个锤子类的实例在没人用的时候，铁匠不去造它，这样做能节约铁匠铺的空间。

#include <QCoreApplication>
#include <QDebug>
///NOTE7单例模式--懒汉单例的线程不安全做法
class Hammer
{private:static Hammer* m_pHammer;Hammer() {qDebug() << "make a new hammer!";}~Hammer() {}Hammer(const Hammer&) = delete;//单例类建议屏蔽拷贝构造函数Hammer &operator =(const Hammer&rhs) = delete;//单例类建议屏蔽拷贝运算符
public:static Hammer* GetHammer(){if(m_pHammer == nullptr){qDebug() << "make a new hammer!";//由于静态变量的资源在程序最后全部统一释放，所以这个new没有对应的delete问题不大，严谨的话也可以加上释放过程m_pHammer = new Hammer();return m_pHammer;}}void Beat(){qDebug() << "I can beat";}
};Hammer* Hammer::m_pHammer = nullptr;int main(int, char **)
{Hammer::GetHammer()->Beat();//获取锤子进行敲打getchar();return 0;
}

上述单例是存在线程安全问题的，比如有两个客人（多线程）同时需要使用锤子，两个客人的访问流程同时走到了锤子是否被实例化那一个if语句中，此时条件都成立，因此就会产生两把不一样的锤子供客人使用，这明显是不符合设计初衷的。可以通过线程操作的一些方法解决，下面再说。

2、饿汉模式

这个模式可以较简单地解决同时有客人光顾的问题。即铁匠是个饿汉，总是担心生意上门了却没锤子可提供，因此铁匠铺开张的时候（类定义时）就把锤子造好等人来用。代码如下：

//饿汉单例
class Hammer
{private:static Hammer* m_pHammer;Hammer(){qDebug() << "make a new hammer!";}~Hammer() {}Hammer(const Hammer&) = delete;//单例类建议屏蔽拷贝构造函数Hammer &operator =(const Hammer&rhs) = delete;//单例类建议屏蔽拷贝运算符
public:static Hammer* GetHammer(){return m_pHammer;//客人访问时直接提供生产好的锤子}void Beat(){qDebug() << "I can beat";}
};
//先将锤子生产好
Hammer* Hammer::m_pHammer = new Hammer();
int main(int, char **)
{Hammer::GetHammer()->Beat();//获取锤子进行敲打getchar();return 0;
}

可以看出，和懒汉模式唯一的区别就在于是否先生产好锤子。这种方式会使得空间占用变多，如果没人使用就白白浪费了。

3懒汉模式的改进

懒汉模式可以采用线程锁的方式进行改进，在铁匠铺装一个自动锁，每次客人进门时自动把门锁上，等锤子造好了再开锁。这样限制两个客人同时对懒汉铁匠进行访问。

#include <QCoreApplication>
#include <QDebug>
#include<thread>
#include<mutex>
#include <Windows.h>
using namespace std;
//懒汉单例的线程安全做法
class Hammer
{private:static Hammer* m_pHammer;static mutex m_Mutex;//加一把锁Hammer(){qDebug() << "make a new hammer!";}~Hammer() {}Hammer(const Hammer&) = delete;//单例类建议屏蔽拷贝构造函数Hammer &operator =(const Hammer&rhs) = delete;//单例类建议屏蔽拷贝运算符
public:static Hammer* GetHammer(){if(m_pHammer == nullptr)//双重判断，如果没锤子，估计会发生客人同时来店的情况，先锁上，然后再看有没有锤子{m_Mutex.lock();if(m_pHammer == nullptr){//由于静态变量的资源在程序最后全部统一释放，所以这个new没有对应的delete问题不大，严谨的话也可以加上释放过程m_pHammer = new Hammer();}m_Mutex.unlock();}return m_pHammer;}void Beat(){qDebug() << "I can beat";}
};Hammer*Hammer::m_pHammer = nullptr;
mutex Hammer::m_Mutex;void Guest1()//客人1需要锤子
{Sleep(1);Hammer::GetHammer()->Beat();
}void Guest2()//客人2需要锤子
{Sleep(1);Hammer::GetHammer()->Beat();
}int main(int, char **)
{thread thread1(Guest1), thread2(Guest2);thread1.detach();thread2.detach();getchar();return 0;
}

4更优雅的方案

以上几种方式都有一个初始化顺序问题，如果有两个单例，其中一个包含另一个，当被包含的未被初始化时会出问题。《EffectiveC++》item4提到了这一点，并提出一种优雅的解决方案。原文是:“将每个non-local static 对象搬到自己的专属函数内（该对象在此函数内被声明为static）。这些函数返回一个reference指向它所含的对象。然后用户调用这些函数，而不是直接指涉这些对象。”做法如下：

#include <QCoreApplication>
#include <QDebug>
#include<thread>
#include<mutex>
#include <Windows.h>
using namespace std;
class Hammer
{public:static Hammer& GetHammer();void Beat(){qDebug() << "I can beat";}
private:Hammer(){qDebug() << "make a new hammer!";}~Hammer(){}Hammer(const Hammer&) = delete;  //单例类建议屏蔽拷贝构造函数Hammer& operator=(const Hammer&) = delete; //单例类建议屏蔽拷贝运算符
};Hammer& Hammer::GetHammer()
{static Hammer hammer;return hammer;
}void Guest1()//客人1需要锤子
{Sleep(1);Hammer::GetHammer().Beat();
}void Guest2()//客人2需要锤子
{Sleep(1);Hammer::GetHammer().Beat();
}
int main(int, char **)
{thread thread1(Guest1), thread2(Guest2);thread1.detach();thread2.detach();getchar();return 0;
}

可以看出，该方法既简单又线程安全，推荐单例模式采用这种方法。