C++单例模式标准写法以及思路分析
第一版,我们在用完后,手动的delete这个单例模式new出来的对象,实际上也是可以的。
但是存在潜在的问题
//第四步的使用
delete tea1;
//delete tea2; 如果再次的delete tea2就会有问题,相当于一块内存,我们delete了两次。
//假设这个tea1 和 tea2是两个不同的模块的开发者开发的,那么手动的写就会有问题,
//假设tea1 的作者是用这个读一个配置文件,读完后他的模块就结束了,那么就会释放这个单例,
// tea2的作者用这个是做一个循环,时间很长,那么当tea1的模块结束的时候,将单例置为null 了,就会有问题。
//因此这里涉及到两个问题:1.使用单例模式的多个模块时,单例被干掉的问题
//2.最好不要手动的delete,因为当delete一次后,单例指向的内存就为NULL了,再次delete就有问题了。
//3.那么怎么解决这两个问题呢?不要让多个模块使用同一个单例,如果使用,请保证在最先释放的模块前,所有的模块都已经使用单例完成了单例相关的工作。
//4.使用内部类完成单例new出来的内存的释放问题
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdio.h>
#include <mutex>
using namespace std;
mutex mymutexTeacher173;
class Teacher173 {
//第一步:将构造函数私有化
private:
Teacher173() {
cout << "私有的构造函数被调用" << endl;
}
//第二步:那么怎么让程序员实例化一个Teacher173呢?
//肯定是要提供一个 public的方法,返回值是Teacher173,
//这个方法还不能是成员函数,因为都无法实例化一个Teacher173,谁去调用呢?因此,只能是static的
//我们还要求是单例的,也就是每次返回的值都必须是一个,那么如果返回值类型是Teacher173,怎么样返回时保证都是同一个呢?
//因此我们要添加一个 Teacher173类型的指针,每次都返回这个指针,而这个指针的初始化在getInstance中完成。
//由于这个getInstance 方法是static的,因此这个Teacher173类型的指针也必须是static的
//第四步:截止到第三步完成,我们就只有一个问题了,new 出来的m_instance = new Teacher173; 什么时候释放呢?
//一般的写法是在不在需要这个单例的时候,手动的delete,,参考步骤四的使用
//第五步:但是实际上开发程序的时候,一个单例,肯定是很多地方在用,那么谁在最后去手动的delete不好说
//因此可以添加一个内部类,实例化的时候添加一个内部类的静态实例,内部类的析构函数中析构外部类Teacher173
//第六步:到这里就都OK,但是如果遇到多个子线程 第一次 去拿这个实例,就有可能有问题。因此要对这块进行再优化
public:
//static Teacher173 getInstance() {
// Teacher173 t;
// return t;
//}
//第五步之前的代码
//static Teacher173* getInstance() {
// if (m_instance==nullptr) {
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第五步添加代码优化
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第6步添加代码优化多线程
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
// //6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
// unique_lock<mutex> myunique_lock(mymutex);
// //6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
// }
// else {
// //6.1 存在,直接 return m_instance
// return m_instance;
// }
//}
//第6步添加代码简化
static Teacher173* getInstance() {
if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
//6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
unique_lock<mutex> myunique_lock(mymutexTeacher173);
//6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
if (m_instance == nullptr) {
static CGhuishou c1;
m_instance = new Teacher173;
return m_instance;
}
}
return m_instance;
}
class CGhuishou {
public:
CGhuishou() {
cout << "内部类被构造调用" << endl;
}
~CGhuishou() {
cout << "内部类被析构调用" << endl;
//由于内部类可以访问外部类的私有成员
if (Teacher173::m_instance != nullptr) {
//delete Teacher173::m_instance;
//Teacher173::m_instance = nullptr;
}
}
};
private:
static Teacher173 *m_instance;
public:
~Teacher173() {
cout << "Teacher173 析构函数被调用" << endl;
}
};
//第三步:使用,静态变量需要初始化
Teacher173* Teacher173::m_instance = nullptr;
void main() {
//Teacher173 tea;//第一步 解释.将Teacher173的构造函数私有化后,就可以防止在哪里都能构造了
//第三步 使用。
Teacher173* tea1 = Teacher173::getInstance();
cout << "tea1 = " << tea1 << " &tea1 address = " << &tea1 << endl;
Teacher173* tea2 = Teacher173::getInstance();
cout << "tea2 = " << tea1 << " &tea2 address = " << &tea2 << endl;
//第三步结果:
//私有的构造函数被调用
// tea1 = 00000264242A7730 &tea1 address = 0000008119EFF9F8
// tea2 = 00000264242A7730 &tea2 address = 0000008119EFFA18
//第四步的使用,,手动的delete这个对象
delete tea1;
delete tea2;
//第五步 的时候,就不用delete tea1了
cout << "end" << endl;
}
第二版,如果我们的代码很长,可能到后面不想手动的delete对象,让代码在销毁的时候,通过内部类可以访问外部类的机制 delete 这个对象的方法。但是个人觉得用处不大。
mutex mymutexTeacher173;
class Teacher173 {
//第一步:将构造函数私有化
private:
Teacher173() {
cout << "私有的构造函数被调用" << endl;
}
//第二步:那么怎么让程序员实例化一个Teacher173呢?
//肯定是要提供一个 public的方法,返回值是Teacher173,
//这个方法还不能是成员函数,因为都无法实例化一个Teacher173,谁去调用呢?因此,只能是static的
//我们还要求是单例的,也就是每次返回的值都必须是一个,那么如果返回值类型是Teacher173,怎么样返回时保证都是同一个呢?
//因此我们要添加一个 Teacher173类型的指针,每次都返回这个指针,而这个指针的初始化在getInstance中完成。
//由于这个getInstance 方法是static的,因此这个Teacher173类型的指针也必须是static的
//第四步:截止到第三步完成,我们就只有一个问题了,new 出来的m_instance = new Teacher173; 什么时候释放呢?
//一般的写法是在不在需要这个单例的时候,手动的delete,,参考步骤四的使用
//第五步:但是实际上开发程序的时候,一个单例,肯定是很多地方在用,那么谁在最后去手动的delete不好说
//因此可以添加一个内部类,实例化的时候添加一个内部类的静态实例,内部类的析构函数中析构外部类Teacher173
//第六步:到这里就都OK,但是如果遇到多个子线程 第一次 去拿这个实例,就有可能有问题。因此要对这块进行再优化
public:
//static Teacher173 getInstance() {
// Teacher173 t;
// return t;
//}
//第五步之前的代码
//static Teacher173* getInstance() {
// if (m_instance==nullptr) {
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第五步添加代码优化
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第6步添加代码优化多线程
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
// //6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
// unique_lock<mutex> myunique_lock(mymutex);
// //6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
// }
// else {
// //6.1 存在,直接 return m_instance
// return m_instance;
// }
//}
//第6步添加代码简化
static Teacher173* getInstance() {
if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
//6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
unique_lock<mutex> myunique_lock(mymutexTeacher173);
//6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
if (m_instance == nullptr) {
static CGhuishou c1;
m_instance = new Teacher173;
return m_instance;
}
}
return m_instance;
}
class CGhuishou {
public:
CGhuishou() {
cout << "内部类被构造调用" << endl;
}
~CGhuishou() {
cout << "内部类被析构调用" << endl;
//由于内部类可以访问外部类的私有成员
if (Teacher173::m_instance != nullptr) {
delete Teacher173::m_instance;
Teacher173::m_instance = nullptr;
}
}
};
private:
static Teacher173 *m_instance;
public:
~Teacher173() {
cout << "Teacher173 析构函数被调用" << endl;
}
};
//第三步:使用,静态变量需要初始化
Teacher173* Teacher173::m_instance = nullptr;
void main() {
//Teacher173 tea;//第一步 解释.将Teacher173的构造函数私有化后,就可以防止在哪里都能构造了
//第三步 使用。
Teacher173* tea1 = Teacher173::getInstance();
cout << "tea1 = " << tea1 << " &tea1 address = " << &tea1 << endl;
Teacher173* tea2 = Teacher173::getInstance();
cout << "tea1 = " << tea1 << " &tea2 address = " << &tea2 << endl;
//第三步结果:
//私有的构造函数被调用
// tea1 = 00000264242A7730 &tea1 address = 0000008119EFF9F8
// tea1 = 00000264242A7730 &tea2 address = 0000008119EFFA18
//第四步的使用
//delete tea1;
//第五步 的时候,就不用delete tea1了
cout <<"end"<< endl;
}
call_once()函数
函数模版,功能是保证四二个参数只能被调用一次,call_once需要和一个标记相结合使用,这个标记为 std::once_flag
once_flag是一个结构体,因此使用时,要初始化一个once_flag
当多个线程执行到call_once()函数时,只有一个可以进去执行,其他的会等,直到第一个执行完毕后,其他的线程会跳过这个函数执行下一步。
mutex mymutexTeacher173;
std::once_flag onlyoneTeacher173;
class Teacher173 {
//第一步:将构造函数私有化
private:
Teacher173() {
cout << "私有的构造函数被调用" << endl;
}
//第二步:那么怎么让程序员实例化一个Teacher173呢?
//肯定是要提供一个 public的方法,返回值是Teacher173,
//这个方法还不能是成员函数,因为都无法实例化一个Teacher173,谁去调用呢?因此,只能是static的
//我们还要求是单例的,也就是每次返回的值都必须是一个,那么如果返回值类型是Teacher173,怎么样返回时保证都是同一个呢?
//因此我们要添加一个 Teacher173类型的指针,每次都返回这个指针,而这个指针的初始化在getInstance中完成。
//由于这个getInstance 方法是static的,因此这个Teacher173类型的指针也必须是static的
//第四步:截止到第三步完成,我们就只有一个问题了,new 出来的m_instance = new Teacher173; 什么时候释放呢?
//一般的写法是在不在需要这个单例的时候,手动的delete,,参考步骤四的使用
//第五步:但是实际上开发程序的时候,一个单例,肯定是很多地方在用,那么谁在最后去手动的delete不好说
//因此可以添加一个内部类,实例化的时候添加一个内部类的静态实例,内部类的析构函数中析构外部类Teacher173
//第六步:到这里就都OK,但是如果遇到多个子线程 第一次 去拿这个实例,就有可能有问题。因此要对这块进行再优化
public:
//static Teacher173 getInstance() {
// Teacher173 t;
// return t;
//}
//第五步之前的代码
//static Teacher173* getInstance() {
// if (m_instance==nullptr) {
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第五步添加代码优化
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
//}
//第6步添加代码优化多线程
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
// //6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
// unique_lock<mutex> myunique_lock(mymutex);
// //6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// else {
// return m_instance;
// }
// }
// else {
// //6.1 存在,直接 return m_instance
// return m_instance;
// }
//}
//第6步添加代码简化
//static Teacher173* getInstance() {
// if (m_instance == nullptr) {//6.1先判断是否有 m_instance了。如果有了,直接return m_instance
// //6.2走到这里说明 ,这时候 m_instance还不存在,但是可能有多个线程都走到这里了,那么就要 lock一下.我们在这里假设有3个线程(假设叫A,B,C线程)都走到这一行了,那么一定有一个线程获得了mutex(假设是B线程获得了锁子,那么A,C线程就要在这里等待了),
// unique_lock<mutex> myunique_lock(mymutexTeacher173);
// //6.3 当B线程完成后,m_instance就有值了,这时候B会释放锁子,A,C再抢,这时候再判断一下 m_instance是否为nullptr为好,如果已经有了,走else路线,直接return m_instance
// if (m_instance == nullptr) {
// static CGhuishou c1;
// m_instance = new Teacher173;
// return m_instance;
// }
// }
// return m_instance;
//}
//额外:第7步使用 call_once来完成
static void getFirstInstance() {
static CGhuishou c1;
m_instance = new Teacher173;
}
//额外:第7步使用 call_once来完成
static Teacher173* getInstance() {
call_once(onlyoneTeacher173, getFirstInstance);
return m_instance;
}
class CGhuishou {
public:
CGhuishou() {
cout << "内部类被构造调用" << endl;
}
~CGhuishou() {
cout << "内部类被析构调用" << endl;
//由于内部类可以访问外部类的私有成员
if (Teacher173::m_instance != nullptr) {
delete Teacher173::m_instance;
Teacher173::m_instance = nullptr;
}
}
};
private:
static Teacher173 *m_instance;
public:
~Teacher173() {
cout << "Teacher173 析构函数被调用" << endl;
}
};
//第三步:使用,静态变量需要初始化
Teacher173* Teacher173::m_instance = nullptr;
void main() {
//Teacher173 tea;//第一步 解释.将Teacher173的构造函数私有化后,就可以防止在哪里都能构造了
//第三步 使用。
Teacher173* tea1 = Teacher173::getInstance();
cout << "tea1 = " << tea1 << " &tea1 address = " << &tea1 << endl;
Teacher173* tea2 = Teacher173::getInstance();
cout << "tea1 = " << tea1 << " &tea2 address = " << &tea2 << endl;
//第三步结果:
//私有的构造函数被调用
// tea1 = 00000264242A7730 &tea1 address = 0000008119EFF9F8
// tea1 = 00000264242A7730 &tea2 address = 0000008119EFFA18
//第四步的使用
//delete tea1;
//第五步 的时候,就不用delete tea1了
cout <<"end"<< endl;
}