目录
基本概念
饿汉式：
懒汉式：
上锁双判空版本
std::call_once版本：
C++11标准后局部静态变量版本：
项目中单例模板的应用
基本概念
单例模式：在程序运行期间只有一份，与程序生存周期一样，因此无需手动释放内存，由程序结束后系统自动回收进程内存。
类单例的方式：
1.构造函数私有化 禁止用户随便构造。
2.创造属于类的私有静态实例并仅限通过静态函数访问实例；
3.拷贝和赋值构造需要私有化或者禁掉。
4.考虑多线程竞态可能创建多个实例等。
UML图：
饿汉式：
类加载即实例化，无线程竞争问题；但可能在实际使用前很久该单例一直未使用，空耗内存。
class EhanSingle
{
public:
EhanSingle(const EhanSingle&) = delete;
EhanSingle&operator = (const EhanSingle&) = delete;
~EhanSingle() = delete;
static EhanSingle* getInstance()
{
return instance;
}
private:
EhanSingle() = default;
static EhanSingle *instance;
};
//类加载即实例化 无线程竞争问题
EhanSingle* EhanSingle::instance = new EhanSingle;懒汉式：
上锁双判空版本
只有在程序实际需要使用单例实例时，才进行初次创建，内存效率较高，但需要考虑线程竞态问题。
该代码中使用了互斥锁+双层判空机制防止产生多个实例；同时使用原子变量防止实例在创建时候由于指令重排可能导致的实例构建失败。
//懒汉
#include<atomic>
#include<mutex>
class LanHanSignle
{
public:
LanHanSignle(const LanHanSignle&) = delete;
LanHanSignle& operator = (const LanHanSignle&) = delete;
~LanHanSignle() = delete;
static LanHanSignle*getInstance()
{
LanHanSignle *instance = atom_instance.load();
if (instance == nullptr)
{
mtx.lock(); //上锁 双层判空防止多线程产生多个
if (instance == nullptr)
{
//atomic存储操作是为了防止指令重排序
//1分配内存 2 在内存构建实例 3 指针指向内存
//重排后可能1,3,2 当2出错后指针指向内存为空但是实例构造失败
instance = new (std::nothrow) LanHanSignle();
atom_instance.store(instance);
}
mtx.unlock();
}
return instance;
}
private:
LanHanSignle();
static std::mutex mtx;
static std::atomic<LanHanSignle*> atom_instance;
};std::call_once版本：
对于只执行一次构造可以采用std::call_once进行延迟实例构造，而且可以避免懒汉需要上锁的问题；但同时也存在一次构造失败会导致后续不会重新构造实例问题。
class LanHanSingleton
{
public:
LanHanSingleton(const LanHanSingleton&) = delete;
LanHanSingleton& operator = (const LanHanSingleton&) = delete;
static LanHanSingleton* getInstance()
{
//如果第一次构造失败后续会一直返回错误的instance
std::call_once(once_flag, LanHanSingleton::createInstance);
return instance;
}
private:
static LanHanSingleton* instance;
static std::once_flag once_flag;
static void createInstance() { instance = new(std::nothrow) LanHanSingleton; }
LanHanSingleton() = default;
~LanHanSingleton() = default;
};
LanHanSingleton* LanHanSingleton::instance = nullptr;
std::once_flag LanHanSingleton::once_flag;C++11标准后局部静态变量版本：
c++11 标准保证指令逻辑进入未被初始化的静态变量，所有并发操作应该等待变量初始化完成；由此可以简化懒汉的线程竞态产生的问题。
//静态局部变量 简化懒汉式
class LanHanSingleStaticLocal
{
public:
LanHanSingleStaticLocal(const LanHanSingleStaticLocal&) = delete;
LanHanSingleStaticLocal& operator = (const LanHanSingleStaticLocal&) = delete;
static LanHanSingleStaticLocal* getInstance()
{
//c++11 标准保证指令逻辑进入未被初始化的声明变量
//所有并发操作应该等待变量初始化完成
static LanHanSingleStaticLocal instance;
return&instance;
}
private:
LanHanSingleStaticLocal() = default;
//不能=delete 局部静态变量退出需要调用
~LanHanSingleStaticLocal() = default;
};项目中单例模板的应用
在项目中一般会有许多全局唯一的变量，如软件的配置文件、数据缓存、数据库的连接池、枚举映射、计费单元、用户单元等等；可以使用单例模板对这些类进行简化编写。
如采用局部静态变量的单例模板如下：
template<typename T>
class Singleton
{
public:
Singleton(const Singleton&) = delete;
Singleton& operator = (const Singleton&) = delete;
static T* getInstance()
{
static T instance;
return&instance;
}
private:
Singleton() = default;
~Singleton() = default;
};新建一个单例缓存类如下：
#pragma once
#include<string>
#include<map>
#include "Signleton.h"
using namespace std;
//宏便于后续使用
#define g_DataCache Singleton<CacheHelper>::getInstance()
class CacheHelper
{
//声明友元 便于单例调用该类私有构造函数
friend Singleton<CacheHelper>;
public:
string getValue(const string&key) const;
void setValue(const string&key, const string&value);
/*
...
*/
private:
CacheHelper() {}
~CacheHelper() {};
std::map<string, string>m_CacheMap;
/*
...
*/
};
使用单例
g_DataCache->setValue("CameraSerialNo","DTS-TP303");
string cameraSerialStr = g_DataCache->getValue("CameraSerialNo");线程池中的应用：
#define g_Get_EtcThreadPool Singleton<EtcThreadPool>::getInstance()
class EtcThreadPool
{
public:
friend Singleton<EtcThreadPool>;
QThreadPool *GetEtcThreadPool();
void DestoryThreadPool();
private:
EtcThreadPool() = default;
~EtcThreadPool() = default;
QMutex m_EtcPoolMutex;
QThreadPool *m_EtcThreadPool = nullptr;
void InitEtcThreadPool();
};
