c++单例设计模式及多线程
1、单例设计模式
1 #include
2 using namespace std;
3
4 class MyCAS{
5 private:
6 MyCAS(){} //私有化构造函数
7 private:
8 static MyCAS *m_instance; //静态成员变量
9 public:
10 static MyCAS *GetInstance(){
11 if(m_instance == NULL){
12 m_instance = new MyCAS();
13 static cGarreceive c1;
14 }
15 return m_instance;
16 }
17 class cGarreceive{
18 public:
19 ~cGarreceive(){
20 if(MyCAS::m_instance){
21 delete MyCAS::m_instance;
22 MyCAS::m_instance = NULL;
23 }
24 }
25 };
26 void func(){
27 cout<<"测试"<func();
35 MyCAS::GetInstance()->func();
36 } 通过将构造函数设置为私有的，不能通类名直接去创建对象，只能通过使用MyCAS类型的指针调用成员函数创建类的对象，每次创建对象是判断是否已经创建了，以此实现单例，通过在类中定义一个类cGarreceive析构成员变量m_instance。
2、单利设计模式共享数据问题分析、解决
如果有两个线程同时调用GetInstance函数创建对象，要避免两个线程同时调用共享数据。
1#include
2 #include
3 #include
4 using namespace std;
5
6 std::mutex resource_mutex;
7 class MyCAS{
8 private:
9 MyCAS(){} //私有化构造函数
10 private:
11 static MyCAS *m_instance; //静态成员变量
12
13 public:
14 static MyCAS *GetInstance(){
15 if(m_instance == NULL){ //双重锁定（双重检查）提高效率
16 std::unique_lock mymutex(resource_mutex); //自动加锁
17 if(m_instance == NULL){
18 m_instance = new MyCAS();
19 static cGarreceive c1;
20 }
21 }
22 return m_instance;
23 }
24 class cGarreceive{
25 public:
26 ~cGarreceive(){
27 if(MyCAS::m_instance){
28 delete MyCAS::m_instance;
29 MyCAS::m_instance = NULL;
30 }
31 }
32 };
33 void func(){
34 cout<<"测试"<func();
44 cout<<"我的线程执行完毕了"<func();
50 //MyCAS::GetInstance()->func();
51 std::thread myobj1(mythread);
52 std::thread myobj2(mythread);
53
54 myobj1.join();
55 myobj2.join();
56
57 return 0;
58 } 
3、call_once（函数模板）的使用
c++11引入的函数，第一个参数是once_flag,只要这个参数被设置成“已调用”状态，则对应的函数a()就不会被调用，该函数的第二个参数是一个函数名a(),call_once函数功能是能够保证函数a()只被调用一次，call_once函数具备互斥能力上比互斥量消耗资源更少。
1#include
2 #include
3 #include
4 #include
5 using namespace std;
6
7 std::mutex resource_mutex;
8 std::once_flag g_flag; //系统定义的标记
9 class MyCAS{
10
11 static void CreateInstance(){
12 std::chrono::milliseconds dura(20000); //休息20秒
13 std::this_thread::sleep_for(dura);
14 cout<<"CreateInstance()执行了"< mymutex(resource_mutex); //自动加锁
28 if(m_instance == NULL){
29 m_instance = new MyCAS();
30 static cGarreceive c1;
31 }
32 }*/
33 std::call_once(g_flag,CreateInstance); //如果两个线程同时到这里，其中一个线程要
//等另外一个执行结束
34 return m_instance;
35 }
36 class cGarreceive{
37 public:
38 ~cGarreceive(){
39 if(MyCAS::m_instance){
40 delete MyCAS::m_instance;
41 MyCAS::m_instance = NULL;
42 }
43 }
44 };
45 void func(){
46 cout<<"测试"<func();
56 cout<<"我的线程执行完毕了"<func();
62 //MyCAS::GetInstance()->func();
63 std::thread myobj1(mythread);
64 std::thread myobj2(mythread);
65
66 myobj1.join();
67 myobj2.join();
68
69 return 0;
70 } 
事实证明只调用了一次CreateInstance函数