UNIX(多线程)：11---单例设计模式共享数据分析，call

单例设计模式

单例：整个项目中，有某个或者某些特殊的类，属于该类的对象，更多关于设计模式的内容可以在公众号的菜单栏里选择设计模式查看。
注意delete指针的技巧：类中套类，利用类对象回收时调用析构函数进行指针等资源的释放。

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class singleClass
{
private:
singleClass() {};  //私有化构造函数
static singleClass* m_instance;  //静态成员变量
public:
static singleClass* GetInstance()
{
if (m_instance == NULL)
{
m_instance = new singleClass();
static GuiderPtr gc;
}
return m_instance;
}
class GuiderPtr   //类中套类，用来释放对象
{
public:
~GuiderPtr()
{
if (singleClass::m_instance)
{
delete singleClass::m_instance;
singleClass::m_instance = NULL;
}
}
};
void func() {
cout << "This is a Test" << endl;
}
};
//类静态变量初始化
singleClass*  singleClass::m_instance = NULL;
int main()
{
singleClass* sg_ptr = singleClass::GetInstance();  //创建一个singleClass类，并返回指针
singleClass* sg_ptr1 = singleClass::GetInstance();  //返回的之前创建的指针
sg_ptr->func();
sg_ptr1->func();
singleClass::GetInstance()->func();
return 0;
}

单例设计模式共享数据问题分析、解决

建议：在创建所有其他线程之前，在主线程中创建出单例对象，加载数据，后续使用。
实际可能面临的问题：需要在我们自己创建的线程（而不是主线程）中来创建singleClass这个单例类的对象，这种线程可能不止一个（最少2个）。
我们可能会面临GetInstance()这种成员函数要互斥。
虽然这两个线程是同一个入口函数，但大家千万要记住，这是两个线程，所以这里会有两个流程（两条通路）同时开始执行mythread这个函数。

考虑加锁方式

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
using namespace std;
std::mutex res_mutex;
class singleClass
{
private:
singleClass() {};  //私有化构造函数
static singleClass* m_instance;  //静态成员变量
public:
static singleClass* GetInstance()
{
//提过效率
//a) 如果if (m_instance != nullptr)  条件成立，则肯定表示 m_instance 已经被new过了
//b) 如果if (m_instance == nullptr) 不代表m_instance一定没被new过
if (m_instance == NULL) //双重锁定（双重检查）
{
std::unique_lock<std::mutex> mutex_getInstance(res_mutex); //自动加锁
if (m_instance == NULL)
{
m_instance = new singleClass();
static GuiderPtr gc;
}
}
return m_instance;
}
class GuiderPtr   //类中套类，用来释放对象
{
public:
~GuiderPtr()
{
if (singleClass::m_instance)
{
delete singleClass::m_instance;
singleClass::m_instance = NULL;
}
}
};
void func() {
cout << "This is a Test" << endl;
}
};
//类静态变量初始化
singleClass*  singleClass::m_instance = NULL;
//线程入口函数
void mythread() {
cout << "线程函数开始执行了" << endl;
singleClass* sgPtr = singleClass::GetInstance();  //这里可能有问题
sgPtr->func();
cout << "线程函数执行完毕了" << endl;
return;
}
int main()
{
std::thread t_obj1(mythread);
std::thread t_obj2(mythread);
t_obj2.join();
t_obj1.join();
return 0;
}

std::call_once(）

C++11引入的函数，该函数的第二个参数是一个函数名 a()。
call_once 功能是能够保证函数a()只被调用一次。
call_once 具备互斥量这种能力，而且效率上，比互斥量消耗的资源更少。
call_once()需要与一个标记结合使用，这个标记 std::once_flag，其实once_flag是一个结构。
call_once()就是通过这个标记来决定对应的函数a()是否执行，调用call_once成功后，call_once()就把这个标记设置为一种已调用状态。

后续再次调用call_once() ,只要once_flag被设置为了“已调用”状态，那么对应的函数a()就不会再被执行了。

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
std::mutex res_mutex;
std::once_flag g_flag; //全局变量，定义的标记
class singleClass
{
private:
singleClass() {};  //私有化构造函数
static singleClass* m_instance;  //静态成员变量
static void CreatInstance()      //只被调用一次
{
std::chrono::milliseconds dura(2000);
std::this_thread::sleep_for(dura);
cout << "CreatInstance()执行了" << endl;
m_instance = new singleClass();
static GuiderPtr gc;
}
public:
static singleClass* GetInstance()
{
//两个线程同时执行到这里，其中一个线程要等另外一个线程执行完毕CreateInstance（）；
std::call_once(g_flag, CreatInstance);
cout << "GetInstance()执行了" << endl;
return m_instance;
}
class GuiderPtr   //类中套类，用来释放对象
{
public:
~GuiderPtr()
{
if (singleClass::m_instance)
{
delete singleClass::m_instance;
singleClass::m_instance = NULL;
}
}
};
void func() {
cout << "This is a Test" << endl;
}
};
//类静态变量初始化
singleClass*  singleClass::m_instance = NULL;
//线程入口函数
void mythread() {
cout << "线程函数开始执行了" << endl;
singleClass* sgPtr = singleClass::GetInstance();  //这里可能有问题
sgPtr->func();
cout << "线程函数执行完毕了" << endl;
return;
}
int main()
{
std::thread t_obj1(mythread);
std::thread t_obj2(mythread);
t_obj2.join();
t_obj1.join();
return 0;
}