标签：互斥 也会 特殊 delete space 正在执行 使用 get nbsp
一、设计模式大概谈
代码的一些写法，与常规的写法不太一样，程序灵活，维护起来很方便，但是别人接管、阅读代码很痛苦。
用设计模式理念写出来的代码很晦涩。<< head first>>
老外应付特别大的项目时候，把项目开发经验、模块划分经验，总结成设计模式。
二、单例设计模式
使用频率高。
单例：整个项目中，有某个特殊或某些特殊的类，属于该类的对象，我只能创建1个，多了我就创建不了了。
单例类（构造函数为private）；
1 class A{//单例类 2 private: 3 A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了 4 static A* m_instance;//静态成员变量 5 public: 6 static A* GetInstance(){ 7 if(m_instance == NULL){ 8 m_instance = new A(); 9 static huishou cl; 10 11 } 12 return m_instance; 13 } 14 15 class huishou{//类中套类，用来释放对象 16 public: 17 ~huishou(){ 18 if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象 19 delete A::m_instance; 20 A::m_instance=NULL; 21 } 22 } 23 } 24 25 }; 26 27 //静态变量初始化 28 A* A::m_instance=NULL; 29 30 A *p_a = A::GetInstance();//第一次调用函数，返回m_instance就非空了，当再次创建就不行了。
三、单例设计模式共享数据问题分析、解决
有时候需要在我们自己创建的线程（不是主线程）中创建A这个单例类的对象，这种线程可能最少2个。我们可能会面临
GetInstance()这个成员函数要互斥，例如：
1 using namespace std; 2 std::mutex resource_mutex; 3 4 5 class A{//单例类 6 private: 7 A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了 8 static A* m_instance;//静态成员变量 9 public: 10 static A* GetInstance(){ 11 std::unique_lock<std::mutex> mymutex(resource_mutex);//会自动加锁 12 if(m_instance == NULL){ 13 m_instance = new A(); 14 static huishou cl; 15 16 } 17 return m_instance; 18 } 19 20 class huishou{//类中套类，用来释放对象 21 public: 22 ~huishou(){ 23 if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象 24 delete A::m_instance; 25 A::m_instance=NULL; 26 } 27 } 28 } 29 30 }; 31 32 //静态变量初始化 33 A* A::m_instance=NULL; 34 35 //线程入口函数 36 void mythread(){ 37 cout << "thread is begining!" <<endl; 38 A* p_a = A::GetInstance();//这里会出问题 39 cout << "this thread over" << endl; 40 return; 41 } 42 43 int main(){ 44 std::thread thread1(mythread); 45 std::thread thread2(mythread); 46 thread1.join(); 47 thread2.join(); 48 return 0; 49 50 }
两个线程的入口函数是相通的，有一种情况可能会发生：当thread1正好创建A对象（正在执行GetInstance）的时候任务被切换到了thread2，那么thread2也会同时执行到GetInstance，相当于两个线程同时执行这个函数，这就坏事了。所以要来一个锁，就行了。
上面的效率太低了，相当于每次创建A都要调用get函数，还要锁上，相当于你这么复杂的步骤，只是为了解决初始化时的问题，这几很低效率了。
怎样高效解决呢？看下面代码：
1 static A* GetInstance(){ 2 //双重锁定提高效率 3 if(m_instance==NULL)//双重锁定，双重检查 4 {
//这段函数也就是只执行一次 5 std::unique_lock<std::mutex> mymutex(resource_mutex);//会自动加锁 6 if(m_instance == NULL){ 7 m_instance = new A(); 8 static huishou cl; 9 } 10 } 11 return m_instance; 12 }
如何提高效率的？
我们知道如果if(m_instance！=NULL)条件成立，表示肯定已m_instance已经被new过了；
如果if(m_instance==NULL)，不代表m_instance一定没有被new过，比如上面说的那种特殊情况。
第一个if条件成功的情况就是第一次创建A对象或者几个线程同时第一次创建A对象的手，才会进入第一个if执行语句中，然后就加锁。。。。。。
一旦这个对象已经创建了，那么第一个if里面的执行语句就根本不会再执行了了。也即是说，第一个if就专门是针对出创A对象或多个线程初创A对象的情况，一旦A对象有了，就再也不会执行里面的语句了，效率高了很多。
四、std::call_once()
函数模板
能够保证函数a只被调用一次。
具备互斥量这种能力，效率上比互斥量消耗更少。
需要与一个标记结合使用，这个标记std::once_flag是一个结构。
根据这个标记来决定对应的函数a是否被执行，调用call_once成功后，call_once()就把这个标记设置为一种已调用状态，对应的a函数就不会再被执行了。
1 using namespace std; 2 std::once_flag m_flag;//系统定义的标记 3 4 class A{//单例类 5 static void creatInstance(){//只被调用一次,不加说明都默认成是private 6 m_instance = new A(); 7 static huishou cl; 8 } 9 private: 10 A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了 11 static A* m_instance;//静态成员变量 12 public: 13 static A* GetInstance(){ 14 //如果两个线程同时执行到这里，其中一个线程要等另外一个线程执行完毕creatInstance() 15 std::call_once(m_flag,creatInstance); 16 return m_instance; 17 } 18 19 class huishou{//类中套类，用来释放对象 20 public: 21 ~huishou(){ 22 if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象 23 delete A::m_instance; 24 A::m_instance=NULL; 25 } 26 } 27 } 28 29 }; 30 31 //静态变量初始化 32 A* A::m_instance=NULL; 33 34 //线程入口函数 35 void mythread(){ 36 cout << "thread is begining!" <<endl; 37 A* p_a = A::GetInstance();//这里会出问题 38 cout << "this thread over" << endl; 39 return; 40 } 41 42 int main(){ 43 std::thread thread1(mythread); 44 std::thread thread2(mythread); 45 thread1.join(); 46 thread2.join(); 47 return 0; 48 49 }
PS:一般建议在主线程中创建单例对象
标签：互斥 也会 特殊 delete space 正在执行 使用 get nbsp
原文地址：https://www.cnblogs.com/pacino12134/p/11240699.html
