七、单例设计模式共享数据分析、解决、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 0;
    
}

两个线程的入口函数是相通的，有一种情况可能会发生：当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 0;
    
}

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