设计模式：单例模式

单例模式

指的是，无论怎么获取，永远只能得到该类类型的唯一一个实例对象，那么设计一个单例就必须要满足下面三个条件：
1.构造函数私有化，这样用户就不能任意定义该类型的对象了
2.定义该类型唯一的对象
3.通过一个static静态成员方法返回唯一的对象实例

饿汉模式

饿汉式单例模式，顾名思义，就是程序启动时就实例化了该对象，并没有推迟到第一次使用该对象时再进行实例化；如果运行过程中没有使用到，该实例对象就被浪费掉了。

#include<iostream>
using namespace std;
class CSingleton
{
public:
	static CSingleton* getInstance()
	{
		return &single;
	}
private:
	static CSingleton single;
	CSingleton() { cout << "CSingleton()" << endl; }
	~CSingleton() { cout << "~CSingleton()" << endl; }
	CSingleton(const CSingleton&);//防止外部使用拷贝构造产生新的对象，如下面CSingleton s = *p1;
};
CSingleton CSingleton::single;

int main()
{
	CSingleton* p1 = CSingleton::getInstance();
	CSingleton* p2 = CSingleton::getInstance();
	CSingleton* p3 = CSingleton::getInstance();
	cout << p1 << " " << p2 << " " << p3 << endl;
	return 0;
}

单例对象定义成了一个static静态对象，它是在程序启动时，main函数运行之前就初始化好的，因此不存在线程安全问题，可以放心的在多线程环境中使用

懒汉式单例模式

通过创建静态对象，c++11是线程安全的

        对象的实例化，延迟到第一次使用它的时候。

        在开发过程中，用的是懒汉模式，这样尽可能延迟对象的创建；

        在C++11 中，考虑线程安全的懒汉式单例：static 是线程安全的，不用考虑加锁

#include <iostream>
using namespace std;

class CSingleton
{
public:
	static CSingleton* getInstance()
	{
		static CSingleton single;//懒汉式单例模式，定义唯一的对象实例
		return &single;
	}
private:
	CSingleton() { cout << "CSingleton()" << endl; }
	~CSingleton() { cout << "~CSingleton()" << endl; }
	CSingleton(const CSingleton&);
};
int main()
{
	CSingleton* p1 = CSingleton::getInstance();
	CSingleton* p2 = CSingleton::getInstance();
	CSingleton* p3 = CSingleton::getInstance();
	return 0;
}

但是这种方式创建的单例在实际应用中，可能会遇到单例析构时候crash,因为单例对象是static，分配在.data段，这块内存由系统负责分配和释放，在系统释放这块内存的时候，我们无法确定系统释放的准确时机，如果析构函数中调用的一些变量或者环境以及提前释放了，则会造成程序crash

使用std::call_once ，通过new 分配在堆中

call_once - C++ Reference

template <class Fn, class... Args>
  void call_once (once_flag& flag, Fn&& fn, Args&&... args);

在C++11中提供一种方法，使得函数可以线程安全的只调用一次。即使用std::call_once和std::once_flag。std::call_once是一种lazy load的很简单易用的机制

示例：

// call_once example
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::milliseconds
#include <mutex>          // std::call_once, std::once_flag

int winner;
void set_winner(int x) { winner = x; }
std::once_flag winner_flag;

void wait_1000ms(int id) {
  // count to 1000, waiting 1ms between increments:
  for (int i = 0; i < 1000; ++i)
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  // claim to be the winner (only the first such call is executed):
  std::call_once(winner_flag, set_winner, id);
}

int main()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i = 0; i < 10; ++i)
    threads[i] = std::thread(wait_1000ms, i + 1);

  std::cout << "waiting for the first among 10 threads to count 1000 ms...\n";

  for (auto& th : threads) th.join();
  std::cout << "winner thread: " << winner << '\n';

  return 0;
}

这段代码的输出将是多线程中最终成功调用：set_winner的线程id,仅由一个线程可以调用。

修改单例代码：

#include<iostream>
#include <mutex>
using namespace std;
class CSingleton
{
public:
  static CSingleton* getInstance()
  {
    static CSingleton* single = nullptr;
    static std::once_flag flag;
    std::call_once(flag, []() {
      if (nullptr == single) {
        single = new CSingleton();
      }
      });

    return single;
  }
private:

  CSingleton() { cout << "CSingleton()" << endl; }
  ~CSingleton() { cout << "~CSingleton()" << endl; }
  CSingleton(const CSingleton&);//防止外部使用拷贝构造产生新的对象，如下面CSingleton s = *p1;
};


int main()
{
  CSingleton* p1 = CSingleton::getInstance();
  CSingleton* p2 = CSingleton::getInstance();
  CSingleton* p3 = CSingleton::getInstance();
  cout << p1 << " " << p2 << " " << p3 << endl;
  return 0;
}