C++单例和std::once_flag

#include <iostream>
#include <mutex>

using namespace std;

 mutex oMutex; //锁

 std::once_flag flag;

class SingerEg
{
public:
    static SingerEg * GetInstance()
    {
        if (SingerEg::s_instance == nullptr) // 可以在单例创建对象前进行双重检查(双重锁定),然后把锁放在第一次检查之后,这个可以提高程序的效率,锁的粒度就会细
        {
            std::lock_guard<std::mutex> oGuardMutex(oMutex);
            if (SingerEg::s_instance == nullptr)
            {
                cout << "单例对象被创建" << endl;
                s_instance = new SingerEg();
                static Release oRelease;
            }
        }
        return s_instance;
    }
    
    class Release
    {
    public:
        ~Release()
        {
            if (SingerEg::s_instance != nullptr)
            {
                delete SingerEg::s_instance;
                SingerEg::s_instance = nullptr;
                cout << "单例对象被正确析构" << endl;
            }
        }

    };
private:
    SingerEg(){} //私有化构造函数
    SingerEg(const SingerEg&){} //私有化拷贝构造函数
    static SingerEg * s_instance;
    
};

SingerEg * SingerEg::s_instance = nullptr;

int main(void)
{
    SingerEg * oSingerEg = SingerEg::GetInstance();
    SingerEg * oSingerEg1 = SingerEg::GetInstance();
    std::call_once(flag, &SingerEg::GetInstance); 
#if 0
    std::once_flag 变量名;
    std::once_flag(变量名, 线程函数);
    flag相当于一个标志位, 可以让一个线程单一执行, 就是一个线程执行之后第二个线程看一下flag的这个标志位, 如果正在执行, 就让它去执行, 如果没有执行, 就执行, 跟互斥锁差不多一个道理
#endif

    return 0;
}