devbox
在线问答5
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计模式之单例模式(C++)_单例模式设计c

作者：在线问答5 | 2024-07-09 09:44:17

赞

踩

单例模式设计c

作者：翟天保Steven
版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处

一、单例模式是什么？

       单例模式是一种创建型的软件设计模式，在工程项目中非常常见。通过单例模式的设计，使得创建的类在当前进程中只有一个实例，并提供一个全局性的访问点，这样可以规避因频繁创建对象而导致的内存飙升情况。

       实现单例模式的三个要点：

1）私有化构造函数：这样外界就无法自由地创建类对象，进而阻止了多个实例的产生。

2）类定义中含有该类的唯一静态私有对象：静态变量存放在全局存储区，且是唯一的，供所有对象使用。

3）用公有的静态函数来获取该实例：提供了访问接口。

       单例模式一般分为懒汉式和饿汉式。

1）懒汉式：在使用类对象（单例实例）时才会去创建它，不然就懒得去搞。

2）饿汉式：单例实例在类装载时构建，有可能全局都没使用过，但它占用了空间，就像等着发救济粮的饿汉提前排好队等吃的一样。

二、懒汉式实现

2.1 懒汉基础实现

       最基本的懒汉实现方法。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. // 单例模式演示类
  8. class Singleton
  9. {
  10. public:
  11. 	// 公有接口获取唯一实例
  12. 	static Singleton* getInstance(){
  13. 		// 若为空则创建
  14. 		if (instance == nullptr) {
  15. 			cout << "实例为空，开始创建。" << endl;
  16. 			instance = new Singleton();
  17. 			cout << "创建结束。" << endl;
  18. 		}
  19. 		else {
  20. 			cout << "已有实例，返回。" << endl;
  21. 		}
  22. 		return instance;
  23. 	}
  24. private:
  25. 	// 私有构造函数
  26. 	Singleton(){
  27. 		cout << "构造函数启动。" << endl;
  28. 	};
  29. 	// 私有析构函数
  30. 	~Singleton(){
  31. 		cout << "析构函数启动。" << endl;
  32. 	};
  33. private:
  34. 	// 静态私有对象
  35. 	static Singleton* instance;
  36. };
  37.  
  38. // 初始化
  39. Singleton* Singleton::instance = nullptr;
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main() 
  9. {
  10. 	cout << "main开始" << endl;
  11. 	Singleton* s1 = Singleton::getInstance();
  12. 	Singleton* s2 = Singleton::getInstance();
  13. 	Singleton* s3 = Singleton::getInstance();
  14. 	cout << "main结束" << endl;
  15. 	return 0;
  16. }

       执行代码，让我们看看结果。

       从结果中可以看出这样设计主要有两个问题，一个是线程安全，另一个是内存泄漏。

       线程安全是因为在多线程场景下，有可能出现多个线程同时进行new操作的情况，没通过加锁来限制。

       内存泄漏是因为使用了new在堆上分配了资源，那么在程序结束时，也应该进行delete，确保堆中数据释放。

       接下来，我们先解决线程安全问题，对懒汉式实现进行改进。

2.2 基于双重检测锁的懒汉实现

       通过双重检测锁，可以确保线程安全。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static Singleton* getInstance(){
  14. 		// 若为空则创建
  15. 		if (instance == nullptr) {
  16. 			// 加锁保证线程安全
  17. 			// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
  18. 			// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
  19. 			lock_guard<mutex> l(m_mutex);
  20. 			if (instance == nullptr) {
  21. 				cout << "实例为空，开始创建。" << endl;
  22. 				instance = new Singleton();
  23. 				cout << "地址为:" << instance << endl;
  24. 				cout << "创建结束。" << endl;
  25. 			}
  26. 		}
  27. 		else {
  28. 			cout << "已有实例，返回。" << endl;
  29. 		}
  30. 		return instance;
  31. 	}
  32. private:
  33. 	// 私有构造函数
  34. 	Singleton(){
  35. 		cout << "构造函数启动。" << endl;
  36. 	};
  37. 	// 私有析构函数
  38. 	~Singleton(){
  39. 		cout << "析构函数启动。" << endl;
  40. 	};
  41. private:
  42. 	// 静态私有对象
  43. 	static Singleton* instance;
  44. 	// 锁
  45. 	static mutex m_mutex;
  46. };
  47.  
  48. // 初始化
  49. Singleton* Singleton::instance = nullptr;
  50. mutex Singleton::m_mutex;
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main() 
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		Singleton* s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		Singleton* s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	Singleton* s3 = Singleton::getInstance();
  20. 	cout << "地址为:" << s3 << endl;
  21. 	cout << "main结束" << endl;
  22. 	return 0;
  23. }

       执行代码，让我们看看结果。

       这样看来没有问题，那如果取消双重检测锁，在多线程下看看会发生什么。将代码部分函数修改为下。把锁注释掉，再查看地址信息。

  1. // 公有接口获取唯一实例
  2. static Singleton* getInstance(){
  3. 	// 若为空则创建
  4. 	if (instance == nullptr) {
  5. 		// 加锁保证线程安全
  6. 		// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
  7. 		// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
  8. 		//lock_guard<mutex> l(m_mutex);
  9. 		if (instance == nullptr) {
  10. 			cout << "实例为空，开始创建。" << endl;
  11. 			instance = new Singleton();
  12. 			cout << "地址为:" << instance << endl;
  13. 			cout << "创建结束。" << endl;
  14. 		}
  15. 	}
  16. 	else {
  17. 		cout << "已有实例，返回。" << endl;
  18. 	}
  19. 	return instance;
  20. }

       此时结果中可以看出，两个线程进行了两次new操作，但是最后只能捕捉到最后一次new的地址信息了，前面的那个丢失了。。。。。

       这个测试也是让大家直观地感受下双重检测锁的用处。

       接下来，我们再解决内存泄漏(资源释放)问题，对懒汉式实现进行进一步的改进。

2.3 基于双重检测锁和资源管理的懒汉实现

       在2.2的基础上，我们加入资源管理机制，以达到对资源的释放的目的，解决方法有两个：智能指针&静态嵌套类。

2.3.1 智能指针方案

       将实例指针更换为智能指针，另外智能指针在初始化时，还需要人为添加公有的毁灭函数，因为析构函数私有化了。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static shared_ptr<Singleton> getInstance(){
  14. 		// 若为空则创建
  15. 		if (instance == nullptr) {
  16. 			// 加锁保证线程安全
  17. 			// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
  18. 			// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
  19. 			lock_guard<mutex> l(m_mutex);
  20. 			if (instance == nullptr) {
  21. 				cout << "实例为空，开始创建。" << endl;
  22. 				instance.reset(new Singleton(), destoryInstance);
  23. 				cout << "地址为:" << instance << endl;
  24. 				cout << "创建结束。" << endl;
  25. 			}
  26. 		}
  27. 		else {
  28. 			cout << "已有实例，返回。" << endl;
  29. 		}
  30. 		return instance;
  31. 	}
  32. 	// 毁灭实例
  33. 	static void destoryInstance(Singleton* x) {
  34. 		cout << "自定义释放实例" << endl;
  35. 		delete x;
  36. 	}
  37. private:
  38. 	// 私有构造函数
  39. 	Singleton(){
  40. 		cout << "构造函数启动。" << endl;
  41. 	};
  42. 	// 私有析构函数
  43. 	~Singleton(){
  44. 		cout << "析构函数启动。" << endl;
  45. 	};
  46. private:
  47. 	// 静态私有对象
  48. 	static shared_ptr<Singleton> instance;
  49. 	// 锁
  50. 	static mutex m_mutex;
  51. };
  52.  
  53. // 初始化
  54. shared_ptr<Singleton> Singleton::instance;
  55. mutex Singleton::m_mutex;
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main() 
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		shared_ptr<Singleton> s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		shared_ptr<Singleton> s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	shared_ptr<Singleton> s3 = Singleton::getInstance();
  20. 	cout << "地址为:" << s3 << endl;
  21. 	cout << "main结束" << endl;
  22. 	return 0;
  23. }

       应用智能指针后，在程序结束时，它自动进行资源的释放，解决了内存泄漏的问题。

2.3.2 静态嵌套类方案

       类中定义一个嵌套类，初始化该类的静态对象，当程序结束时，该对象进行析构的同时，将单例实例也删除了。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static Singleton* getInstance() {
  14. 		// 若为空则创建
  15. 		if (instance == nullptr) {
  16. 			// 加锁保证线程安全
  17. 			// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
  18. 			// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
  19. 			lock_guard<mutex> l(m_mutex);
  20. 			if (instance == nullptr) {
  21. 				cout << "实例为空，开始创建。" << endl;
  22. 				instance = new Singleton();
  23. 				cout << "地址为:" << instance << endl;
  24. 				cout << "创建结束。" << endl;
  25. 			}
  26. 		}
  27. 		else {
  28. 			cout << "已有实例，返回。" << endl;
  29. 		}
  30. 		return instance;
  31. 	}
  32. private:
  33. 	// 私有构造函数
  34. 	Singleton() {
  35. 		cout << "构造函数启动。" << endl;
  36. 	};
  37. 	// 私有析构函数
  38. 	~Singleton() {
  39. 		cout << "析构函数启动。" << endl;
  40. 	};
  41. 	// 定义一个删除器
  42. 	class Deleter {
  43. 	public:
  44. 		Deleter() {};
  45. 		~Deleter() {
  46. 			if (instance != nullptr) {
  47. 				cout << "删除器启动。" << endl;
  48. 				delete instance;
  49. 				instance = nullptr;
  50. 			}
  51. 		}
  52. 	};
  53. 	// 删除器是嵌套类,当该静态对象销毁的时候，也会将单例实例销毁
  54. 	static Deleter m_deleter;
  55. private:
  56. 	// 静态私有对象
  57. 	static Singleton* instance;
  58. 	// 锁
  59. 	static mutex m_mutex;
  60. };
  61.  
  62. // 初始化
  63. Singleton* Singleton::instance = nullptr;
  64. mutex Singleton::m_mutex;
  65. Singleton::Deleter Singleton::m_deleter;

      main.h同2.2中的一致，结果如下，可以看出，当嵌套类Deleter对象销毁时，其析构函数执行的实例删除操作也完成了。

2.4 基于局部静态对象的懒汉实现

       C++11后，规定了局部静态对象在多线程场景下的初始化行为，只有在首次访问时才会创建实例，后续不再创建而是获取。若未创建成功，其他的线程在进行到这步时会自动等待。注意C++11前的版本不是这样的。

       因为有上述的改动，所以出现了一种更简洁方便优雅的实现方法，基于局部静态对象实现。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static Singleton& getInstance() {
  14. 		cout << "获取实例" << endl;
  15. 		static Singleton instance;
  16. 		cout << "地址为:" << &instance << endl;
  17. 		return instance;
  18. 	}
  19. private:
  20. 	// 私有构造函数
  21. 	Singleton() {
  22. 		cout << "构造函数启动。" << endl;
  23. 	};
  24. 	// 私有析构函数
  25. 	~Singleton() {
  26. 		cout << "析构函数启动。" << endl;
  27. 	};
  28. };
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		Singleton &s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		Singleton &s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	cout << "main结束" << endl;
  20. 	return 0;
  21. }

       从结果中可以看出，构造函数启动了一次，另一个线程直接获取了地址。并且当程序结束时，进行了自动释放。

三、饿汉式实现

3.1 饿汉基础实现

       饿汉和懒汉的差别就在于，饿汉提前进行了创建，所以它的基础实现也不是很复杂，如下所示。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static Singleton* getInstance() {
  14. 		cout << "获取实例" << endl;
  15. 		cout << "地址为:" << instance << endl;
  16. 		return instance;
  17. 	}
  18. private:
  19. 	// 私有构造函数
  20. 	Singleton() {
  21. 		cout << "构造函数启动。" << endl;
  22. 	};
  23. 	// 私有析构函数
  24. 	~Singleton() {
  25. 		cout << "析构函数启动。" << endl;
  26. 	};
  27. private:
  28. 	// 静态私有对象
  29. 	static Singleton* instance;
  30. };
  31.  
  32. // 初始化
  33. Singleton* Singleton::instance = new Singleton();
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		Singleton* s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		Singleton* s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	cout << "main结束" << endl;
  20. 	return 0;
  21. }

       输出结果中可知，main还没开始，实例就已经构建完毕，获取实例的函数也不需要进行判空操作，因此也就不用双重检测锁来保证线程安全了，它本身已经是线程安全状态了。

       但是内存泄漏的问题还是要解决的，这点同懒汉是一样的。

3.2 基于资源管理的饿汉实现

       内存泄漏解决方法有两个：智能指针&静态嵌套类。

3.2.1 智能指针方案

       将实例指针更换为智能指针，另外智能指针在初始化时，还需要人为添加公有的毁灭函数，因为析构函数私有化了。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static shared_ptr<Singleton> getInstance() {
  14. 		cout << "获取实例" << endl;
  15. 		cout << "地址为:" << instance << endl;
  16. 		return instance;
  17. 	}
  18. 	// 毁灭实例
  19. 	static void destoryInstance(Singleton* x) {
  20. 		cout << "自定义释放实例" << endl;
  21. 		delete x;
  22. 	}
  23. private:
  24. 	// 私有构造函数
  25. 	Singleton() {
  26. 		cout << "构造函数启动。" << endl;
  27. 	};
  28. 	// 私有析构函数
  29. 	~Singleton() {
  30. 		cout << "析构函数启动。" << endl;
  31. 	};
  32. private:
  33. 	// 静态私有对象
  34. 	static shared_ptr<Singleton> instance;
  35. };
  36.  
  37. // 初始化
  38. shared_ptr<Singleton> Singleton::instance(new Singleton(), destoryInstance);
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		shared_ptr<Singleton> s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		shared_ptr<Singleton> s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	cout << "main结束" << endl;
  20. 	return 0;
  21. }

       加入了智能指针后，不出意外地进行了自动的资源释放。

3.2.2 静态嵌套类方案

       类中定义一个嵌套类，初始化该类的静态对象，当程序结束时，该对象进行析构的同时，将单例实例也删除了。

  1. //Singleton.h
  2. /****************************************************/
  3. #include <iostream>
  4. #include <mutex>
  5.  
  6. using namespace std;
  7.  
  8. // 单例模式演示类
  9. class Singleton
  10. {
  11. public:
  12. 	// 公有接口获取唯一实例
  13. 	static Singleton* getInstance() {
  14. 		cout << "获取实例" << endl;
  15. 		cout << "地址为:" << instance << endl;
  16. 		return instance;
  17. 	}
  18. private:
  19. 	// 私有构造函数
  20. 	Singleton() {
  21. 		cout << "构造函数启动。" << endl;
  22. 	};
  23. 	// 私有析构函数
  24. 	~Singleton() {
  25. 		cout << "析构函数启动。" << endl;
  26. 	};
  27. 	// 定义一个删除器
  28. 	class Deleter {
  29. 	public:
  30. 		Deleter() {};
  31. 		~Deleter() {
  32. 			if (instance != nullptr) {
  33. 				cout << "删除器启动。" << endl;
  34. 				delete instance;
  35. 				instance = nullptr;
  36. 			}
  37. 		}
  38. 	};
  39. 	// 删除器是嵌套类,当该静态对象销毁的时候，也会将单例实例销毁
  40. 	static Deleter m_deleter;
  41. private:
  42. 	// 静态私有对象
  43. 	static Singleton* instance;
  44. };
  45.  
  46. // 初始化
  47. Singleton* Singleton::instance = new Singleton();
  48. Singleton::Deleter Singleton::m_deleter;
  1. //main.cpp
  2. /****************************************************/
  3. #include <iostream>
  4. #include "Singleton.h"
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10. 	cout << "main开始" << endl;
  11. 	thread t1([] {
  12. 		Singleton* s1 = Singleton::getInstance();
  13. 	});
  14. 	thread t2([] {
  15. 		Singleton* s2 = Singleton::getInstance();
  16. 	});
  17. 	t1.join();
  18. 	t2.join();
  19. 	cout << "main结束" << endl;
  20. 	return 0;
  21. }

       同懒汉的一样，不多做阐述。

四、总结

       上述讲了这么多关于单例模式的内容，我尽可能地将测试的结果也同步展示了，目的就是帮助大家更好地理解。文中所有的代码都是完整的，可以直接复制到自己的项目中测试验证下。

       最后，如果说让我选择用什么样的实现，那我选择用局部静态对象的方法，代码简洁，线程安全，内存无泄漏，有什么理由说不呢？除非你是C++11之前的版本。。。。

       如果文章帮助到你了，可以点个赞让我知道，我会很快乐~加油！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/在线问答5/article/detail/802060
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号