《1》设计模式大概谈
????????所谓“设计模式”，指的是代码的一些写法（这些写法与常规的写法不一样）。它会使得程序变得灵活，维护起来可能方便。但，用设计模式理念写出来的代码很晦涩，别人接管、阅读代码都会很痛苦，需要下很大功夫才能搞clear。
????????设计模式最先是老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理而成的。0几年设计模式在中国刚开始火时，程序员们总喜欢拿一个设计模式往项目代码上套，导致一个小小的项目总要加几个设计模式，这就本末倒置了。
? ? ? ? 但不可否认的是，设计模式有其独特的优点，作为程序员，一定要活学活用，不要深陷其中，生搬硬套！
《2》单例设计模式（常用）
????????在整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。这即为单例设计模式。
????????单例类：只能生成该类的一个对象。
demo_codes：
#include<iostream>
using namespace std;
//单例类例子codes
class MyCLS {
private:
MyCLS(){}//私有化类的构造函数时，类外部就不可以用className ObjName的方式来创建类的对象了。
private:
static MyCLS* m_instance;//静态成员变量必须是类内声明，类外初始化
public:
static MyCLS* getInstance() {
if (m_instance == nullptr) {
m_instance = new MyCLS();
static CGarHuishou cl;
//静态局部变量 <==> 全局变量（在整一个程序运行结束时，其作用域才end）
//so才可以用另外一个类来帮助我delete上述在heap区开辟内存空间的m_instance指针
}
//shared_ptr<MyCLS>(make_shared())
return m_instance;
}
void func() {
static int nums = 0;
nums++;
cout << "test codes " <<nums<< endl;
}
class CGarHuishou {//类中嵌套另一个类，这个类专门用于析构单例类中的new的对象所占据的内存空间！
public:
~CGarHuishou() {
if (MyCLS::m_instance) {//非空 再delete，若本来就是空则不要重复delete
delete MyCLS::m_instance;
MyCLS::m_instance = nullptr;
cout << "~CGarHuishou()执行了！" << endl;
}
}
};
};
//静态成员变量必须是类内声明，类外初始化
MyCLS* MyCLS::m_instance = nullptr;
int main(void) {
MyCLS* weiyiObj = MyCLS::getInstance();//因为是static成员，所以要用::符号来使用该函数！
MyCLS* weiyiObj2 = MyCLS::getInstance();//因为是static成员，所以要用::符号来使用该函数！
weiyiObj->func();
weiyiObj2->func();
MyCLS::getInstance()->func();
if (weiyiObj == weiyiObj2)cout << "weiyiObj == weiyiObj2" << endl;
else cout<< "weiyiObj != weiyiObj2" << endl;
//从运行结果来看，这2个指针都指向同一块内存，说明只可以产生一个该类的对象！
//也即，实际上，都只是产生了一块内存而已！
return 0;
}运行结果：
《3》单例设计模式共享数据问题分析、解决
????????一般，我们都是在主线程中（main函数内）创建单例类的对象，这一不会引起任何问题。
????????但是，现在我们面临着另一个问题：需要在自己创建的线程中（非主线程中）来创建单例类的对象（比如上述所说的MyCLS类），这种线程可能不止一个。此时，我们可能面临多个GetInstance()成员函数需要互斥的情况。
????????可以在加锁前判断m_instance是否为空，否则每次调用Singleton::getInstance()都要加锁，十分影响效率。
????????因为每次调用MyCLS::getInstance()都要加锁，十分影响效率。因此，在加锁前再次判断m_instance是否为空（这即为双重锁定/双重检查）。
demo_codes：（please仔细看注释，and you will get what I say！）
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
std::mutex my_mutex;
//单例类例子codes
class MyCLS {
private:
MyCLS(){}//私有化类的构造函数时，类外部就不可以用className ObjName的方式来创建类的对象了。
private:
static MyCLS* m_instance;//静态成员变量必须是类内声明，类外初始化
public:
//首先你得承认一个事实是：
//如果if (m_instance != nullptr) 条件成立，一定代表m_instance一定被new过了
//如果if (m_instance == nullptr) 条件成立，并不代表m_instance一定没被new过了
//下面这个创建对象指针的函数getInstance()就算多个线程一起共享的代码数据！
static MyCLS* getInstance() {
??? //因为每次调用MyCLS::getInstance()都要加锁，十分影响效率。
//因此，在加锁前再次判断m_instance是否为空（这即为双重锁定/双重检查）。
if (m_instance == nullptr) {//这就叫做是双重检查or双重锁定
std::lock_guard<std::mutex> sbguard(my_mutex);//自动加锁
if (m_instance == nullptr) {
m_instance = new MyCLS();
static CGarHuishou cl;//静态成员
}
}
return m_instance;
}
void func() {
static int nums = 0;
nums++;
cout << "test codes " <<nums<< endl;
}
class CGarHuishou {//类中嵌套另一个类，这个类专门用于析构单例类中的new的对象所占据的内存空间！
public:
~CGarHuishou() {
if (MyCLS::m_instance) {//非空 再delete
delete MyCLS::m_instance;
MyCLS::m_instance = nullptr;
cout << "~CGarHuishou()执行了！" << endl;
}
}
};
};
//静态成员变量必须是类内声明，类外初始化
MyCLS* MyCLS::m_instance = nullptr;
//线程入口函数
void mythread() {
cout << "我的线程开始执行了!" << endl;
MyCLS* p_a = MyCLS::getInstance();//这里很可能就会出问题了！
cout << "我的线程执行完毕了!" << endl;
return;
}
int main(void) {
//创建了2个线程,虽然这2个线程都分别走的是同一条通路，
//但是，毕竟是2个线程，彼此互不相关
//这时候问题就来了，当mytobj1这个线程1执行到MyCLS* p_a = MyCLS::getInstance();时
//刚刚准备调用MyCLS类的getInstance函数中的m_instance = new MyCLS();这行代码时，还没运行呢
//操作系统就切换到mytobj2这个线程2中去了，比如此时线程2刚好new了MyCLS对象后，操作系统又切换回
//mytobj1这个线程1中去，那么此时线程1又会new一个MyCLS对象！那么此时就会有2个MyCLS对象的出现
//这就出现问题了，因为单例类中只允许创建一个对象！
//此时，就可以用双重锁定的way去deal该问题！
thread mytobj1(mythread);
thread mytobj2(mythread);
mytobj1.join();
mytobj2.join();
return 0;
}《4》std::call_once()
????????std::call_once()函数模板：保证一个函数只被调用一次（C++11引入的函数模板）
????????格式：
std:once_flag flagObjName;
std::call_once(flagObjName,funcName);????????std::call_once()保证一个函数只被调用一次的原理：
????????call_once()需要与一个标记配合使用，这个标记是：std::once_flag（它是一个结构体）。通过std::once_flag这个标记，call_once()就可以决定对应的函数名为funcName的函数是否能执行1次了。当once_flag设置为“未调用”状态时，call_once()很自然地允许别的代码调用该funcName函数一次，然后将once_flag设置为“已调用”状态。那么此后无论有多少次对于该funcName函数的调用，call_once函数模板都不会允许！
? ? ? ? 解释：
????????之所以能保证该funcName函数只被调用一次。本质上是因为std::call_once这个函数模板具有mutex互斥量的功能。因此可以实现出：当多个线程同时执行时，一个线程会等待另一个线程先执行的效果（和mutex互斥量一样的效果）。
demo_codes：（please仔细看注释，and you will get what I say！）
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
std::mutex my_mutex;
std::once_flag g_flag;//这是一个系统定义的标记
//单例类例子codes
class MyCLS {
public:
static void CreateInstance() {//只允许该函数被调用一次！s
if (m_instance == nullptr) {
m_instance = new MyCLS();
static CGarHuishou cl;//静态成员
}
}
private:
MyCLS(){}//私有化类的构造函数时，类外部就不可以用className ObjName的方式来创建类的对象了。
private:
static MyCLS* m_instance;//静态成员变量必须是类内声明，类外初始化
public:
//下面这个创建对象指针的函数getInstance()就算多个线程一起共享的代码数据！
static MyCLS* getInstance() {
//if (m_instance == nullptr) {//这就叫做是双重检查or双重锁定
// std::lock_guard<std::mutex> sbguard(my_mutex);//自动加锁
// if (m_instance == nullptr) {
// m_instance = new MyCLS();
// static CGarHuishou cl;//静态成员
// }
//}
std::call_once(g_flag, CreateInstance);
cout << "call_once执行完毕！" << endl;
//当2个线程都执行到此处时，其中一个线程要等待另一个线程执行完CreateInstance()函数才能够再次调用call_once函数
//但是此时g_flag已经被标记为“已调用”状态了，so此时另一个线程就不能再次调用此CreateInstance()函数了！
//这样就deal 了单例设计模式中写多线程代码时所出现的问题！
return m_instance;
}
void func() {
static int nums = 0;
nums++;
cout << "test codes " <<nums<< endl;
}
class CGarHuishou {//类中嵌套另一个类，这个类专门用于析构单例类中的new的对象所占据的内存空间！
public:
~CGarHuishou() {
if (MyCLS::m_instance) {//非空 再delete
delete MyCLS::m_instance;
MyCLS::m_instance = nullptr;
cout << "~CGarHuishou()执行了！" << endl;
}
}
};
};
//静态成员变量必须是类内声明，类外初始化
MyCLS* MyCLS::m_instance = nullptr;
//线程入口函数
void mythread() {
cout << "我的线程开始执行了!" << endl;
MyCLS* p_a = MyCLS::getInstance();//这里很可能就会出问题了！
cout << "我的线程执行完毕了!" << endl;
return;
}
int main(void) {
//创建了2个线程,虽然这2个线程都分别走的是同一条通路，
//但是，毕竟是2个线程，彼此互不相关
//这时候问题就来了，当mytobj1这个线程1执行到MyCLS* p_a = MyCLS::getInstance();时
//刚刚准备调用MyCLS类的getInstance函数中的m_instance = new MyCLS();这行代码时，还没运行呢
//操作系统就切换到mytobj2这个线程2中去了，比如此时线程2刚好new了MyCLS对象后，操作系统又切换回
//mytobj1这个线程1中去，那么此时线程1又会new一个MyCLS对象！那么此时就会有2个MyCLS对象的出现
//这就出现问题了，因为单例类中只允许创建一个对象！
thread mytobj1(mythread);
thread mytobj2(mythread);
mytobj1.join();
mytobj2.join();
return 0;
}