笔记

设计模式，把项目开发经验总结，模块化。
单例模式：
整个项目中，有某个或者某些特殊类，属于该类的对象，有且只能创建一个。

class mySys
{
public:
    static mySys* GetInstance()
    {
        if (m_instance == nullptr)
        {
            m_instance = new mySys;
            static GC cl;
        }
        return m_instance;
    }
    class GC
    {
    public:
        ~GC()
        {
            if (mySys::m_instance)
            {
                delete mySys::m_instance;
                mySys::m_instance = nullptr;
            }
        }
    };
private:
    mySys(){}//私有化构造不能创建
private:
    static mySys* m_instance;
};
mySys* mySys::m_instance = nullptr;
int main()
{
    mySys* demo = mySys::GetInstance();
    mySys* demo2 = mySys::GetInstance();
    return 0;
}

回顾：static的声明周期是到程序结束运行，那么等程序结束时候自然会调用GC这个类的析构，把这个内存释放掉。

std::mutex resource_mutex;
class mySys
{
public:
    static mySys* GetInstance()
    {
        if (m_instance == NULL)
        {
            std::unique_lock myobj(resource_mutex);
            if (m_instance == NULL)
            {
                m_instance = new mySys;
                static GC cl;
            }
        }
        return m_instance;
    }
    class GC
    {
    public:
        ~GC()
        {
            if (mySys::m_instance)
            {
                delete mySys::m_instance;
                mySys::m_instance = NULL;
            }
        }
    };
public:
    void fun()
    {
        cout << "test" << endl;
    }
private:
    mySys(){}//私有化构造不能创建
private:
    static mySys* m_instance;
};
mySys* mySys::m_instance = nullptr;
void mythread()
{
    mySys::GetInstance()->fun();
    cout << "Success" << endl;
}
int main()
{
    
    std::thread x1(mythread);
    std::thread x2(mythread);
    x1.join();
    x2.join();
    return 0;
}

同一个线程入口函数，都执行了单例创建，加上了锁做判定，并优化代码提高了运行效率（双重锁定）

设置一个call_flag，一个自己的标记，修改单例类，也可以用call_once来代替锁

std::once_flag myflag;//设置flag
class mySys
{
public:
    static void CreatInstance()
    {
        m_instance = new mySys;
        static GC cl;
    }
public:
    static mySys* GetInstance()
    {
        std::call_once(myflag, CreatInstance);//执行call_once
        return m_instance;
    }
    class GC
    {
    public:
        ~GC()
        {
            if (mySys::m_instance)
            {
                delete mySys::m_instance;
                mySys::m_instance = NULL;
            }
        }
    };
public:
    void fun()
    {
        cout << "test" << endl;
    }
private:
    mySys(){}//私有化构造不能创建
private:
    static mySys* m_instance;
};
mySys* mySys::m_instance = nullptr;
void mythread()
{
    mySys::GetInstance()->fun();
    cout << "Success" << endl;
}
int main()
{
    
    std::thread x1(mythread);
    std::thread x2(mythread);
    x1.join();
    x2.join();
    return 0;
}

条件参数
wait();作用，用来等一个东西
简单来说，
如果wait有第二个参数，就判断这个表达式，为false，就休眠等待有函数调用notify_one这个方法
如果第二个参数返回TRUE，wait就返回，在上锁的情况下执行后面代码
如果没有第二个参数，wait返回，跟false一致，会先解锁，但是会阻塞到此行，直到有函数调用notify_one这个方法为止。代码如下：

std::condition_variable mycond;
class RecvA
{
public:

    void inMsgRecvQueue()
    {
        for (int i = 0; i < 1000; i++)
        {
            cout << "插入元素" << i << endl;
            std::unique_lock sdgard(my_mutex);
            msgRecvQueue.push_back(i);
            mycond.notify_one();//把wait线程唤醒
        }
        return;
    }

    void outMsgRecvQueue()
    {
        int commond = 0;
        while (true)
        {
            std::unique_lock sdgard(my_mutex);
            mycond.wait(sdgard, [this]()->bool
            {
                if (!msgRecvQueue.empty())
                {
                    return true;
                }
                return false;
            });
            commond = msgRecvQueue.front();//先进先出
            msgRecvQueue.pop_front();//移除掉第一个已经取出的元素
            cout << "取数据成功:" << commond << endl;
            sdgard.unlock();//此处提前解锁
        }
    }
private:
    std::list msgRecvQueue;//接收的信息
    std::mutex my_mutex;
};
int main()
{
    RecvA myobj;
    std::thread outRec(&RecvA::outMsgRecvQueue, &myobj);
    std::thread inRec(&RecvA::inMsgRecvQueue, &myobj);
    outRec.join();
    inRec.join();
    return 0;
}