设计模式——单例模式
设计模式：
设计模式代表了最佳实践，是软件开发过程中面临一般问题的解决方案。 设计模式是一套被反复使用、经过分类、代码设计总结的经验。
单例模式
单例模式也叫单件模式。Singleton是一个非常常用的设计模式，几乎所有稍微大一些的程序都会使用到它，所以构建一个线程安全并且 高效的Singleton很重要。
1. 单例类保证全局只有一个唯一实例对象。
2. 单例类提供获取这个唯一实例的接口。
由于要求只生成一个实例，因此我们必须把构造函数的访问权限标记为protected或private，限制只能在类内创建对象.
单例类要提供一个访问唯一实例的接口函数（全局访问点），就需要在类中定义一个static函数，返回在类内部唯一构造的实例。
（这样还可以确保直接用类名就能访问到该唯一实例，不必用到实例化出的对象名去调用）
两个概念：
懒汉模式 （lazy loading ）：第一次调用GetInstance才创建实例对象，比较复杂
饿汉模式： 程序一运行，就创建实例对象、简洁高效 ，但有些场景下不适用
方法一：不考虑线程安全，只适用于单线程环境的单例类
定义一个静态的实例，在需要的时候创建该实例 （懒汉模式）
class Singleton
{
public:
//获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
if (_instance == NULL)
{
_instance = new Singleton();
}
return _instance;
}
static void DelInstance()
{
if (_instance != NULL)
{
delete _instance;
_instance = NULL;
}
}
void Print()
{
cout << _data << endl;
}
protected:
//构造函数标记为protected或private，限制只能在类内创建对象
Singleton()
:_data(5)
{}
//防拷贝
Singleton(const Singleton&);
Singleton operator=(const Singleton&);
private:
//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
static Singleton* _instance; // 单实例对象
int _data; //单实例对象中的数据
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;
这种方法是最简单、最普遍的方法。只有在_instance为NULL的时候才会创建一个实例以避免重复创建。同时我们把构造函数定义为私有函数，这样就能确保只创建一个实例。
但是上述的代码在单线程的时候工作正常，在多线程的情况下就有问题了。
设想如果两个线程同时运行到判断_instance是否为NULL的 if 语句那里，并且_instance之前并未创建时，这两个线程各自就都会创建一实例，这是就无法满足单例模式的要求了。
方法二：能在多线程环境下工作，但是效率不高
为了保障在多线程环境下只得到一个实例，需要加一把互斥锁。把上述代码稍作修改，即：
ps: 下面部分的加锁使用了C++11库的互斥锁
class Singleton
{
public:
//获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
//lock(); //C++中没有直接的lock()
//RAII
//lock lk;
_sMtx.lock(); //C++11
if (_instance == NULL)
{
_instance = new Singleton();
}
//unlock();
_sMtx.unlock();
return _instance;
}
static void DelInstance()
{
if (_instance != NULL)
{
delete _instance;
_instance = NULL;
}
}
void Print()
{
cout << _data << endl;
}
protected:
//构造函数标记为protected或private，限制只能在类内创建对象
Singleton()
:_data(5)
{}
//防拷贝
Singleton(const Singleton&);
Singleton operator=(const Singleton&);
private:
//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
static Singleton* _instance; // 单实例对象
int _data; // 单实例对象中的数据
static mutex _sMtx; // 互斥锁
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;
mutex Singleton::_sMtx;
设想有两个线程同时想创建一个实例，由于在一个时刻，只有一个线程能得到互斥锁，所以当第一个线程加上锁后，第二个线程就只能等待。当第一个线程发现实例还没有创建时，它就建立一个实例。接着第一个线程释放锁，此时第二个线程进入并上锁，这个时候由于实例已经被第一个线程创建出来了，第二个线程就不会重复创建实例了，这样就保证在多线程环境下只能得到一个实例。
但是，每次获取唯一实例，程序都会加锁，而加锁是一个非常耗时的操作，在没有必要的时候，我们要尽量避免，否则会影响性能。
方法三：使用双重检查，提高效率，避免高并发场景下每次获取实例对象都进行加锁，并使用内存栅栏防止重排
class Singleton
{
public:
//获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
// 使用双重检查，提高效率，避免高并发场景下每次获取实例对象都进行加锁
if (_instance == NULL)
{
std::lock_guard<std::mutex> lck(_sMtx);
if (_instance == NULL)
{
// tmp = new Singleton()分为以下三个部分
// 1.分配空间2.调用构造函数3.赋值
// 编译器编译优化可能会把2和3进行指令重排，这样可能会导致高并发场景下，其他线程获取到未调用构造函数初始化的对象
// 以下加入内存栅栏进行处理，防止编译器重排栅栏后面的赋值到内存栅栏之前
Singleton* tmp = new Singleton();
MemoryBarrier(); //内存栅栏
_instance = tmp;
}
}
return _instance;
}
static void DelInstance()
{
if (_instance != NULL)
{
delete _instance;
_instance = NULL;
}
}
void Print()
{
cout << _data << endl;
}
protected:
//构造函数标记为protected或private，限制只能在类内创建对象
Singleton()
:_data(5)
{}
//防拷贝
Singleton(const Singleton&);
Singleton operator=(const Singleton&);
private:
//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
static Singleton* _instance; // 单实例对象
int _data; // 单实例对象中的数据
static mutex _sMtx; // 互斥锁
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;
mutex Singleton::_sMtx;
试想，当实例还未创建时，由于 Singleton == NULL ，所以很明显，两个线程都可以通过第一重的 if 判断 ，进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 if 判断 ，而另外的一个线程则会在 lock 语句的外面等待。而当第一个线程执行完 new Singleton（）语句退出锁定区域，第二个线程便可以进入 lock 语句块，此时，如果没有第二重Singleton == NULL的话，那么第二个线程还是可以调用 new Singleton（）语句，第二个线程仍旧会创建一个 Singleton 实例，这样也还是违背了单例模式的初衷的，所以这里必须要使用双重检查锁定（第二层if 判断必须存在）。
多数现代计算机为了提高性能而采取乱序执行，这使得内存栅栏成为必须。barrier就象是代码中的一个栅栏，将代码逻辑分成两段，barrier之前的代码和barrier之后的代码在经过编译器编译后顺序不能乱掉。也就是说，barrier之后的代码对应的汇编，不能跑到barrier之前去，反之亦然。之所以这么做是因为在我们这个场景中，如果编译器为了榨取CPU的performace而对汇编指令进行重排，其它线程获取到未调用构造函数初始化的对象，很有可能导致出错。
只有第一次调用_instance为NULL，并且试图创建实例的时候才需要加锁，当_instance已经创建出来后，则没必要加锁。这样的修改比之前的时间效率要好很多。
但是这样的实现比较复杂，容易出错，我们还可以利用饿汉模式，创建相对简洁高效的单例模式。
方法四：饿汉模式--简洁、高效、不用加锁、但是在某些场景下会有缺陷
因为静态成员的初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。
class Singleton
{
public:
//获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
assert(_instance);
return _instance;
}
void Print()
{
cout << _data << endl;
}
protected:
//构造函数标记为protected或private，限制只能在类内创建对象
Singleton()
:_data(5)
{}
//防拷贝
Singleton(const Singleton&);
Singleton operator=(const Singleton&);
private:
static Singleton* _instance; // 单实例对象
int _data; // 单实例对象中的数据
};
Singleton* Singleton::_instance = new Singleton;
代码实现非常简洁。创建的实例_instance并不是在第一次调用GetInstance接口函数时才创建，而是在初始化静态变量的时候就创建一个实例。如果按照该方法会过早的创建实例，从而降低内存的使用效率。
方法五：方法四还可以再简化点
class Singleton
{
public:
//获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
static Singleton instance;
return &instance;
}
void Print()
{
cout << _data << endl;
}
protected:
//构造函数标记为protected或private，限制只能在类内创建对象
Singleton()
:_data(5)
{}
//防拷贝
Singleton(const Singleton&);
Singleton operator=(const Singleton&);
private:
int _data; // 单实例对象中的数据
};
实例销毁
此处使用了一个内部GC类，而该类的作用就是用来释放资源
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//带RAII GC自动回收实例对象的方式
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Singleton
{
public:
// 获取唯一对象实例的接口函数
static Singleton* GetInstance()
{
assert(_instance);
return _instance;
}
// 删除实例对象
static void DelInstance()
{
if (_instance)
{
delete _instance;
_instance = NULL;
}
}
void Print()
{
cout << _data << endl;
}
class GC
{
public:
~GC()
{
cout << "DelInstance()" << endl;
DelInstance();
}
};
private:
Singleton()
:_data(5)
{}
static Singleton*_instance;
int _data;
};
// 静态对象在main函数之前初始化，这时只有主线程运行，所以是线程安全的。
Singleton* Singleton::_instance = new Singleton;
// 使用RAII，定义全局的GC对象释放对象实例
Singleton::GC gc;
在程序运行结束时，系统会调用Singleton中GC的析构函数，该析构函数会进行资源的释放。
