七、单例设计模式共享数据分析、解决、call_once

一、设计模式大概谈

代码的一些写法，与常规的写法不太一样，程序灵活，维护起来很方便，但是别人接管、阅读代码很痛苦。

用设计模式理念写出来的代码很晦涩。<< head first>>

老外应付特别大的项目时候，把项目开发经验、模块划分经验，总结成设计模式。

二、单例设计模式

使用频率高。

单例：整个项目中，有某个特殊或某些特殊的类，属于该类的对象，我只能创建1个，多了我就创建不了了。

单例类（构造函数为private）；

 class A{//单例类
 private:
     A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了
     static A* m_instance;//静态成员变量
 public:
     static A* GetInstance(){
         if(m_instance == NULL){
             m_instance = new A();
             static huishou cl;

         }
         return m_instance;
     }

     class huishou{//类中套类，用来释放对象
     public:
         ~huishou(){
             if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象
             delete A::m_instance;
             A::m_instance=NULL;
             }
         }
     }

 };

 //静态变量初始化
 A* A::m_instance=NULL;

 A *p_a = A::GetInstance();//第一次调用函数，返回m_instance就非空了，当再次创建就不行了。

三、单例设计模式共享数据问题分析、解决

有时候需要在我们自己创建的线程（不是主线程）中创建A这个单例类的对象，这种线程可能最少2个。我们可能会面临

GetInstance()这个成员函数要互斥，例如：

 using namespace std;
 std::mutex resource_mutex;

 class A{//单例类
 private:
     A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了
     static A* m_instance;//静态成员变量
 public:
     static A* GetInstance(){
         std::unique_lock<std::mutex> mymutex(resource_mutex);//会自动加锁
         if(m_instance == NULL){
             m_instance = new A();
             static huishou cl;

         }
         return m_instance;
     }

     class huishou{//类中套类，用来释放对象
     public:
         ~huishou(){
             if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象
             delete A::m_instance;
             A::m_instance=NULL;
             }
         }
     }

 };

 //静态变量初始化
 A* A::m_instance=NULL;

 //线程入口函数
 void mythread(){
     cout << "thread is begining!" <<endl;
     A* p_a = A::GetInstance();//这里会出问题
     cout << "this thread over" << endl;
     return;
 }

 int main(){
     std::thread thread1(mythread);
     std::thread thread2(mythread);
     thread1.join();
     thread2.join();
     return ;

 }

两个线程的入口函数是相通的，有一种情况可能会发生：当thread1正好创建A对象（正在执行GetInstance）的时候任务被切换到了thread2，那么thread2也会同时执行到GetInstance，相当于两个线程同时执行这个函数，这就坏事了。所以要来一个锁，就行了。

上面的效率太低了，相当于每次创建A都要调用get函数，还要锁上，相当于你这么复杂的步骤，只是为了解决初始化时的问题，这几很低效率了。

怎样高效解决呢？看下面代码：

     static A* GetInstance(){
         //双重锁定提高效率
         if(m_instance==NULL)//双重锁定，双重检查
         {
　　　　　　　　　//这段函数也就是只执行一次
 5             std::unique_lock<std::mutex> mymutex(resource_mutex);//会自动加锁
 6             if(m_instance == NULL){
 7                 m_instance = new A();
 8                 static huishou cl;
 9             }
         }
         return m_instance;
     }

如何提高效率的？

我们知道如果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函数就不会再被执行了。

 using namespace std;
 std::once_flag m_flag;//系统定义的标记

 class A{//单例类
     static void creatInstance(){//只被调用一次,不加说明都默认成是private
         m_instance = new A();
         static huishou cl;
     }
 private:
     A() {} //私有化构造函数，就不能用A a；这种方式来创建对象了
     static A* m_instance;//静态成员变量
 public:
     static A* GetInstance(){
         //如果两个线程同时执行到这里，其中一个线程要等另外一个线程执行完毕creatInstance()
         std::call_once(m_flag,creatInstance);
         return m_instance;
     }

     class huishou{//类中套类，用来释放对象
     public:
         ~huishou(){
             if(A::m_instance){//如果这个m_instance不是空，那么就得释放A对象
             delete A::m_instance;
             A::m_instance=NULL;
             }
         }
     }

 };

 //静态变量初始化
 A* A::m_instance=NULL;

 //线程入口函数
 void mythread(){
     cout << "thread is begining!" <<endl;
     A* p_a = A::GetInstance();//这里会出问题
     cout << "this thread over" << endl;
     return;
 }

 int main(){
     std::thread thread1(mythread);
     std::thread thread2(mythread);
     thread1.join();
     thread2.join();
     return ;

 }

PS:一般建议在主线程中创建单例对象