设计模式
示例代码:
#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; } return m_instance; } class CGarhuishou //类中套类,用来释放对象 { public: ~CGarhuishou() { if (MyCAS::m_instance) { delete MyCAS::m_instance; MyCAS::m_instance = NULL; } } }; void func() { cout << "测试" << endl; } }; //类静态变量初始化 MyCAS* MyCAS::m_instance = NULL; int main() { MyCAS* p_a = MyCAS::GetInstance(); //创建一个对象,返回该类(MyCAS)对象的指针 MyCAS* p_b = MyCAS::GetInstance(); p_a->func(); MyCAS::GetInstance()->func(); return 0; }
MyCAS
这个单例类的对象,这种线程可能不止1个(至少2个)。GetInstance()
这种成员函数要互斥。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() { if (m_instance == NULL) //双重锁定(双重检查) { std::unique_lock<std::mutex> mymutex(resource_mutex); if (m_instance == NULL) { m_instance = new MyCAS(); static CGarhuishou cl; } } return m_instance; } class CGarhuishou //类中套类,用来释放对象 { public: ~CGarhuishou() { if (MyCAS::m_instance) { delete MyCAS::m_instance; MyCAS::m_instance = NULL; } } }; void func() { cout << "测试" << endl; } }; //类静态变量初始化 MyCAS* MyCAS::m_instance = NULL; void mythread() { cout << "我的线程开始执行了" << endl; MyCAS* p_a = MyCAS::GetInstance(); cout << "我的线程执行完毕了" << endl; } int main() { std::thread mytobj1(mythread); std::thread mytobj2(mythread); /*虽然这两个线程是同一个入口函数, 但大家千万要记住,这是两个线程, 所以这里会有两个流程(两条通路)同时开始执行mythread这个函数 */ mytobj1.join(); mytobj2.join(); return 0; }
std::call_once()
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 <thread> #include <mutex> using namespace std; std::mutex resource_mutex; std::once_flag g_flag; //系统定义的标记 class MyCAS { static void CreatInstance() //只被调用一次 { std::chrono::milliseconds dura(20000); //休息20s std::this_thread::sleep_for(dura); cout << "CreatInstance()被执行了" << 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() cout << "call_once()执行完毕" << endl; return m_instance; } class CGarhuishou //类中套类,用来释放对象 { public: ~CGarhuishou() { if (MyCAS::m_instance) { delete MyCAS::m_instance; MyCAS::m_instance = NULL; } } }; void func() { cout << "测试" << endl; } }; //类静态变量初始化 MyCAS* MyCAS::m_instance = NULL; void mythread() { cout << "我的线程开始执行了" << endl; MyCAS* p_a = MyCAS::GetInstance(); p_a->func(); cout << "我的线程执行完毕了" << endl; return; } int main() { std::thread mytobj1(mythread); std::thread mytobj2(mythread); /*虽然这两个线程是同一个入口函数, 但大家千万要记住,这是两个线程, 所以这里会有两个流程(两条通路)同时开始执行mythread这个函数 */ mytobj1.join(); mytobj2.join(); return 0; }
std::call_once
的效率实际上比双重锁定要低,还是建议使用双重锁定。注:本人学习c++多线程视频地址:C++多线程学习地址