一、单例模式
1)将所有构造函数私有化,用静态指针来指向该对象,
2)静态成员函数初始化静态变量,同时调用将静态变量指向该地址
3)采用类中类的方式,来回收静态变量的地址
//由于m_instance内存未被回收,因此会出现内存泄漏
class MyCas {
private:
MyCas() {};//私有化构造函数
static MyCas* m_instance;//静态成员变量
public:
static MyCas* GetInstance() {
if (m_instance == nullptr) {
m_instance = new MyCas();
static Recycle re;
}
return m_instance;
}
//采用类中类,在类种类中的析构函数回收静态变量的内存
class Recycle {
public:
~Recycle() {
if (MyCas::m_instance) {
delete MyCas::m_instance;
MyCas::m_instance = nullptr;
}
}
};
void func() {
cout << "测试" << endl;
}
};
MyCas* MyCas::m_instance = nullptr;
int main() {
MyCas* p_cas = MyCas::GetInstance();
MyCas::GetInstance()->func();
}
应该在主线程中创建单例对象,尽量避免在子线程中创建,如果要在子线程中创建,则需要使用互斥量或者call_once函数
#include "pch.h"
#include <iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>
using namespace std;
mutex re_mutex;
once_flag flag;//这是一个结构,与call_once一起使用
//由于m_instance内存未被回收,因此会出现内存泄漏
class MyCas {
private:
MyCas() {};//私有化构造函数
~MyCas() {};
static MyCas* m_instance;//静态成员变量
public:
static void CreatrInstance() {
this_thread::sleep_for(chrono::milliseconds(2000));
m_instance = new MyCas();
static Recycle re;
cout << "Cre被执行" << endl;
}
static MyCas* GetInstance() {
// if (m_instance == nullptr) {
// unique_lock<mutex> guard(re_mutex);
// if (m_instance == nullptr) {
// m_instance = new MyCas();
// static Recycle re;
// }
// }
call_once(flag, CreatrInstance);//第一个为once_flag结构,第二个为调用的函数
cout << "call_once执行完毕" << endl;
return m_instance;
}
//采用类中类,在类种类中的析构函数回收静态变量的内存
class Recycle {
public:
~Recycle() {
if (m_instance) {
delete m_instance;
m_instance = nullptr;
}
}
};
void func() {
cout << "测试" << endl;
}
};
MyCas* MyCas::m_instance = nullptr;
void mythread() {
MyCas* p_a = MyCas::GetInstance();
cout << "我的线程开始执行了" << endl;
}
int main() {
/*MyCas* p_cas = MyCas::GetInstance();
MyCas::GetInstance()->func();*/
thread myobj1(mythread);
thread myobj2(mythread);
myobj1.join();
myobj2.join();
}