第七节 单例设计模式共享数据分析、解决,call_once
1.设计模式
- 程序灵活,维护起来可能方便,用设计模式理念写出来的代码很晦涩,但是别人接管、阅读代码都会很痛苦
- 用“设计模式”理念写出来的代码是很晦涩的;《head first》
- 老外应付特别大的项目时,把项目的开发经验、模块划分经验,总结整理成设计模式
- 中国零几年设计模式刚开始火时,总喜欢拿一个设计模式往上套,导致一个小小的项目总要加几个设计模式,本末倒置
- 设计模式有其独特的优点,要活学活用,不要深陷其中,生搬硬套
- 这些年设计模式说的少了,没那么火了
2.单例设计模式:
- 整个项目中,有某个或者某些特殊的类,只能创建一个属于该类的对象。
- 单例类:只能生成一个对象。
- 如果觉得在单例模式new了一个对象,而没有自己delete掉,这样不合理。可以增加一个类中类CGarhuishou,new一个单例类时创建一个静态的CGarhuishou对象,这样在程序结束时会调用CGarhuishou的析构函数,释放掉new出来的单例对象。
#include<iostream>
using namespace std;
//单例类设计模式
class MyCAS
{
private:
MyCAS() {}//私有化了构造函数
private:
static MyCAS *m_instance;//静态成员变量
public:
static MyCAS *Getinstance()
{
if (m_instance == NULL)
{
m_instance = new MyCAS();
static CGarhuishou cl;//在析构cl对象时,来delete m_instance对象
}
return m_instance;
}
class CGarhuishou //类中套类,用来释放对象
{
public:
~CGarhuishou()//类的析构函数中delete
{
if (MyCAS::m_instance)
{
delete MyCAS::m_instance;
MyCAS::m_instance = NULL;
}
}
};
void func()
{
cout << "测试" << endl;
}
};
//类静态变量初始化在类外面,如果静态成员是const的,则可以在类声明中初始化
MyCAS *MyCAS::m_instance = NULL;
int main()
{
//MyCAS a;//私有化了构造函数,就不能这样创建类对象了,只能调用Getinstrance()接口
MyCAS *p_a = MyCAS::Getinstance();//创建一个对象,返回该类(MuCAS)对象的指针
MyCAS *p_b = MyCAS::Getinstance();//m_instance不为空,直接返回,也指向上个对象
//这两个返回的是唯一的单例类指针
p_a->func();
MyCAS::Getinstance()->func();
return 0;
}
3.单例设计模式共享数据分析、解决
- 在主线程中创建MyCAS单例类对象,该装载的变量装载好(变量都是只读的),这样就不存在共享数据问题。
- 面临问题:需要在自己创建的线程中来创建单例类的对象,这种线程可能不止一个(至少2个)。这时我们可能面临GetInstance()这种成员函数需要互斥。
- 可以在加锁前判断m_instance是否为空,否则每次调用Singelton::getInstance()都要加锁,十分影响效率。
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
std::mutex resource_mutex;
//单例类
class MyCAS
{
private:
MyCAS() {}//私有化了构造函数
private:
static MyCAS *m_instance;//静态成员变量
public:
static MyCAS *Getinstance()
{
//a)如果if (m_instance != NULL) 条件成立,则肯定表示m_instrance已经被new过了
//b) 如果if (m_instance == NULL),且没有加锁,不代表m_instrance没被new过,可能另一个线程new的
if (m_instance == NULL)//双重锁定(双重检查) 高效 能保证不用每次调用都加锁,仅在初始化时加锁
{
std::unique_lock<std::mutex> mymutex(resource_mutex);//自动加锁 仅在第一次创建时才有意义 低效
if (m_instance == NULL)
{
m_instance = new MyCAS();
static CGarhuishou cl;//在析构cl对象时,来delete m_instance对象
}
}
return m_instance;
}
class CGarhuishou //类中套类,用来释放对象
{
public:
~CGarhuishou()//类的析构函数中delete
{
if (MyCAS::m_instance)
{
delete MyCAS::m_instance;
MyCAS::m_instance = NULL;
}
}
};
void func()
{
cout << "测试" << endl;
}
};
//类静态变量初始化在类外面,如果静态成员是const的,则可以在类声明中初始化
MyCAS *MyCAS::m_instance = NULL;
//线程入口函数
void mythread()
{
cout << "我的线程开始了" << endl;
MyCAS *p_a = MyCAS::Getinstance();//这里就可能有问题了
cout << "我的线程执行完了" << endl;
return;
}
int main()
{
//虽然两个线程是同一个入口函数,但这是两个线程,所以这里有两条通路同时执行mythread函数
//可能两个线程都new了一个MyCAS的对象
std::thread myobj1(mythread);
std::thread myobj2(mythread);
myobj1.join();
myobj2.join();
return 0;
}
4.std::call_once():
- C++11引入的函数模板,该函数的第一个参数为标记,第二个参数是一个函数名(如a())。
- 功能:能够保证函数a()只被调用一次。具备互斥量的能力,而且比互斥量消耗的资源更少,更高效(待测试)。
- call_once()需要与一个标记结合使用,这个标记为std::once_flag;其实once_flag是一个结构,call_once()就是通过这个标记来决定对应的函数是否执行,调用a()成功后,就把标记位设置为一种已调用状态。后续再次调用call_once,只要once_flag是已调用状态,那么对应的函数就a()就不会再被调用了
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
std::once_flag g_flag;//现在这是个系统定义的标记
//单例类
class MyCAS
{
static void CreatInstance()
{
std::chrono::milliseconds dura(20000);//休息20s 调试看结果用
std::this_thread::sleep_for(dura);
cout << "CreatInsrtance()被执行了" << endl;
m_instance = new MyCAS();
static CGarhuishou cl;
}
private:
MyCAS() {}//私有化了构造函数
private:
static MyCAS *m_instance;//静态成员变量
public:
static MyCAS *Getinstance()
{
std::call_once(g_flag, CreatInstance);//两个线程同时执行到这里,其中一个线程会等另一个线程执行完毕CreatInstance
//可以把g_flag看成一把锁 第一个线程调用calll_once更改了g_flag标记,保证CreatInstance只会被执行一次
cout << "call_once执行完毕" << endl;
return m_instance;
}
class CGarhuishou //类中套类,用来释放对象
{
public:
~CGarhuishou()//类的析构函数中delete
{
if (MyCAS::m_instance)
{
delete MyCAS::m_instance;
MyCAS::m_instance = NULL;
}
}
};
void func()
{
cout << "测试" << endl;
}
};
//类静态变量初始化在类外面,如果静态成员是const的,则可以在类声明中初始化
MyCAS *MyCAS::m_instance = NULL;
//线程入口函数
void mythread()
{
cout << "我的线程开始执行了" << endl;
MyCAS *p_a = MyCAS::Getinstance();//这里就可能有问题了
cout << "我的线程执行完毕了" << endl;
return;
}
int main()
{
//虽然两个线程是同一个入口函数,但这是两个线程,所以这里有两条通路同时执行mythread函数
//可能两个线程都new了一个MyCAS的对象
std::thread myobj1(mythread);
std::thread myobj2(mythread);
myobj1.join();
myobj2.join();
return 0;
}
建议:在主线程中将单例对象创建出来,该初始化的初始化,然后再创建子线程,就不会出现在子线程里多次new单例对象的情况了。双重锁定效率可能更好一点,推荐使用。