53 C++ 多线程 ------ 单例模式 共享数据分析，解决，以及call_once()函数的使用

已于 2024-03-29 11:18:31 修改
阅读量587 收藏 8
点赞数 7
文章标签： c++ 单例模式
于 2024-01-16 14:14:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hunandede/article/details/135623120
版权

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;
}

hunandede
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[C++ 11多线程] --- call_once
M2嵌入式
10-25 208
在某些特定情况下，某些函数只能在多线程环境下调用一次，比如：要初始化某个对象，而这个对象只能被初始化一次，就可以使用 std::call_once() 来保证函数在多线程环境下只能被调用一次。使用 call_once() 的时候，需要一个 once_flag 作为 call_once() 的传入参数，该函数的原型如下： // 定义于头文件 <mutex> template< class Callable, class... Args > void call_once( std::on
单例模式 与 call_once
一十一的博客
08-12 435
文章目录单例模式懒汉式不适用互斥使用互斥饿汉式call_once 实现单例类 单例模式 单例模式，也叫单子模式，是一种常用的软件设计模式。 在应用这个模式时，单例对象的类必须保证只有一个实例存在。 许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。 懒汉式 不适用互斥 mutex singelton_mutex; class Singelton { public: ...
c++ call_once 单例
虾球
11-12 2469
#include <iostream> #include <mutex> #include <pthread.h> constexpr auto times = 50; class MySingleton { public: static MySingleton &getInstance() { std::call_once(initInstanceFlag, &MySingleton::initSingleton);
单例类设计模式、call_once
2301_78933228的博客
05-10 424
std::call_once需要一个 std::once_flag（实际上是一个结构） 对象作为参数，该对象用于跟踪函数是否已经执行过。如果函数尚未执行，std::call_once就会执行提供的可调用对象（通常是一个函数或 lambda 表达式），并将 std::once_flag设置为已执行状态。如果函数已经执行过，std::call_once`则不会再次执行它。当第一次调用该该静态函数时，就会创建该类的唯一实例对象，当此后再调用该静态函数时，则返回已经创建的实例对象，不再创建新的实例对象。
单例模式与call_once
guanxunmeng8928的博客
08-18 278
//Design Pattern /*1.程序灵活，维护方便，但是接管难 2.适用于大项目，不要生搬硬套 */ //单例设计模式： /* 整个程序中某个或者某些特殊的类，他们只能创建一个对象（一般为数据共享）。 单例类，只能生成一个对向。 设计模式共享数据问题分析，解决 如果数据是只读的，多个线程同时调用没有问题，所以单例一般适合在只读数据上使用。 一般单例用来储存全局唯一变量。例如银行的货币的汇率。 建议：在创建其他线程之前，在主线程中就把单例的成员初始化和数据装载。 */ //在子线程中创建单例 /*
C++11 单例模式 std::call_once实现
qq_43331089的博客
03-25 1051
C++11 单例模式 std::call_once实现 class Singleton { public: static Singleton* getInstance() { static std::once_flag onceFlag; // 必须是静态的 std::call_once(onceFlag, [&] {m_instance = new Singleton(); }); // 只会调用一次 return m_instance; } private: Singlet
C++并发与多线程 单例模式共享数据分析与问题解决、call_once
qq_44800780的博客
03-15 381
单例模式介绍与例子 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例 例子如下： using namespace std; class single { private: single() {} private: static single * instance; public: static single* Getinstance() {...
C++11并发与多线程笔记（7） 单例设计模式共享数据分析、解决，call_once
qq_38231713的博客
05-13 4051
第七节 单例设计模式共享数据分析、解决，call_once 1.设计模式 程序灵活，维护起来可能方便，用设计模式理念写出来的代码很晦涩，但是别人接管、阅读代码都会很痛苦 老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理成设计模式 中国零几年设计模式刚开始火时，总喜欢拿一个设计模式往上套，导致一个小小的项目总要加几个设计模式，本末倒置 设计模式有其独特的优点，要活学活用，不要深陷其中，生搬硬套 2.单例设计模式： 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。 单例类：
c++设计模式-单例模式
06-03
**单例模式**是软件设计模式中的一种，属于创建型模式。在C++中，单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于管理共享资源，如数据库连接、日志系统或者配置文件等。单例模式的主要...
使用C++11实现线程安全的单例模式
04-05
线程安全的单例模式在多线程环境下尤其重要，因为不正确的实现可能导致多个线程创建多个实例，这违反了单例模式的基本原则。C++11引入了新的特性，如std::mutex和std::call_once，使得实现线程安全的单例模式变得...
c++11下call_once的单例模式
weixin_41644391的博客
10-24 1306
1. 背景： 单例模式分什么懒汉、饿汉啥的，大家只要懂得概念应付面试就好了。单例模式一般是资源管理器呀，什么全局唯一的一些东西，其实并不需要什么性能，也不会占用太大内存，有的时候甚至都不用考虑加锁，有些不持续的内存泄露也无妨。 2. 单例模式 比较建议使用饿汉模式，饿汉模式的分配是不考虑竞争的，仅分配一次的，不影响性能的。 class Obj { private: Obj() Obj(const Obj& o); public: static Obj* in..
单例模式与call_once；
weixin_43384504的博客
08-14 217
单例模式的概念： 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。 下面是单例类的实现代码： #include <iostream> using namespace std; class A { private: A() {} static A* m_A; public: static A* GetInstance() { if (m_A == NULL) { m_A = new A(); static B cl; } return
c++单例模式和call_once函数
weixin_44651073的博客
03-06 1264
单例模式懒汉式和饿汉式，call_one函数使用
C++并发编程(6)：单例模式、once_flag与call_once、call_once实现单例
工大机器人工作室
05-15 1616
主要学习介绍C++并行编程的基础知识，做一些学习记录并分享
4.17-c++多线程学习-call_once与其使用场景（单例模式场景）
the1shy的博客
04-17 359
缺点是不管是否使用对象都会进行实例化，可能会浪费一定的内存空间。缺点是在多线程环境下需要考虑线程安全问题。可以被用于初始化单例模式中的唯一实例或者其他需要被全局初始化的对象。由于单例实例是全局唯一的，因此在多线程环境中使用单例模式时，需要考虑线程安全的问题。饿汉模式是在程序启动时就进行实例化，之后每次调用都返回同一个实例。因为实例在程序启动时就已经创建，所以不存在线程安全性的问题。懒汉模式是在第一次使用单例对象时才进行实例化，之后每次调用都返回第一次创建的实例。懒汉模式和饿汉模式都是单例模式的实现方式。
C++11实现线程安全的单例模式(使用std call_once)_c++ 单例 std call_once(2)
最新发布
2303_79055586的博客
05-16 1013
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
（八）单例设计模式共享数据分析， call_once
u011886519的博客
02-23 224
单例模式： 整个项目中只能有一个单例类对象，不能创建多个； 简单实现的例子： //单例类 class MySingleClass { private: MySingleClass() {};//私有化构造函数 这样就不能创建多个对象了 private: static MySingleClass* m_instance; public: static MySingleClass* GetInstance() { if (m_instance == NULL) { m_instance
C++11手撕线程池 call_once 单例模式 Singleton / condition_variable 与其使用场景
呵呵哒!的博客
01-21 861
【代码】call_once 单例模式 Singleton。
多线程学习：std::call_once与其使用场景
m0_74318075的博客
01-20 594
std::call_once` 的作用是，确保在多个线程中同时调用 `call_once` 时，只有一个线程能够成功执行 `func` 函数，而其他线程则会等待该函数执行完成。4. `std::call_once` 函数会抛出 `std::system_error` 异常，如果在调用 `func` 函数时发生了异常，则该异常会被传递给调用者。1. `flag` 参数必须是一个 `std::once_flag` 类型的对象，并且在多次调用 `call_once` 函数时需要使用同一个 `flag` 对象。
C++实现优雅的单例模式
在这个版本中，我们引入了`std::call_once`和`std::once_flag`，确保`CreateSingleton`函数只被调用一次，即使在多线程环境中。同时，为了防止意外的复制和赋值，我们禁用了拷贝构造函数和赋值运算符。 此外，由于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值