单例模式【C++设计模式】
文章目录
- 单例模式
- 饿汉模式
- 懒汉模式
- 单例场景
单例模式
饿汉模式
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
- 提供一个指向单例对象的static指针，并在程序入口之前完成单例对象的初始化。
- 提供一个全局访问点获取单例对象
class Singleton
{
public:
//3、提供一个全局访问点获取单例对象
static Singleton* GetInstance()
{
return _inst;
}
private:
//1、将构造函数设置为私有，并防拷贝
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
//2、提供一个指向单例对象的static指针
static Singleton* _inst;
};
//在程序入口之前完成单例对象的初始化
Singleton* Singleton::_inst = new Singleton;
线程安全相关问题：
饿汉模式在程序运行主函数之前就完成了单例对象的创建，由于main函数之前是不存在多线程的，因此饿汉模式下单例对象的创建过程是线程安全的
后续所有多线程要访问这个单例对象，都需要通过调用GetInstance函数来获取，这个获取过程是不需要加锁的，因为这是一个读操作
当然，如果线程通过GetInstance获取到单例对象后，要用这个单例对象进行一些线程不安全的操作，那么这时就需要加锁了
例如：
#include<map>
#include<string>
#include<iostream>
using namespace std;
class Singleton
{
public:
//提供获取单例对象的接口函数
static Singleton& GetInstance()
{
return _sinst;
}
void func();
void Add(const pair<string, string>& kv)
{
_dict[kv.first] = kv.second;
}
void Print()
{
for (auto& e : _dict)
{
cout << e.first << ":" << e.second << endl;
}
cout << endl;
}
private:
// 1、构造函数私有
Singleton()
{
// ...
}
// 3、防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
map<string, string> _dict;
// 静态实例
static Singleton _sinst;
};
Singleton Singleton::_sinst;
int main()
{
//Singleton::GetInstance();
cout << &Singleton::GetInstance() << endl;
cout << &Singleton::GetInstance() << endl;
cout << &Singleton::GetInstance() << endl;
// Singleton copy(Singleton::GetInstance());
Singleton::GetInstance().Add({ "xxx", "111" });
Singleton::GetInstance().Add({ "yyy", "222" });
Singleton::GetInstance().Add({ "zzzzz", "333" });
Singleton::GetInstance().Add({ "abc", "333" });
Singleton::GetInstance().Print();
}
懒汉模式
- 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
- 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空。
- 提供一个全局访问点获取单例对象
class Singleton
{
public:
//3、提供一个全局访问点获取单例对象
static Singleton* GetInstance()
{
//双检查
if (_inst == nullptr)
{
_mtx.lock();
if (_inst == nullptr)
{
_inst = new Singleton;
}
_mtx.unlock();
}
return _inst;
}
private:
//1、将构造函数设置为私有，并防拷贝
Singleton()
{}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
//2、提供一个指向单例对象的static指针
static Singleton* _inst;
static mutex _mtx; //互斥锁
};
//在程序入口之前先将static指针初始化为空
Singleton* Singleton::_inst = nullptr;
mutex Singleton::_mtx; //初始化互斥锁
饿汉模式的优点就是简单，但是它的缺点也比较明显。饿汉模式在程序运行主函数之前就会创建单例对象，如果单例类的构造函数中所做的工作比较多，就会导致程序迟迟无法进入主函数，在外部看来就好像是程序卡住了。
此外，如果有多个单例类需要创建单例对象，并且它们之间的初始化存在某种依赖关系，比如单例对象A的创建必须在单例对象B之后，此时饿汉模式也会存在问题，因为我们无法保证这多个单例对象中的哪个对象先创建
而懒汉模式就能很好的解决上述饿汉模式的缺点，因为懒汉模式并不是一开始就完成单例对象的创建，因此不会导致程序迟迟无法进入主函数，并且懒汉模式中各个单例对象创建的顺序是由各个单例类中的GetInstance函数第一次被调用的顺序决定，因此是可控制的。
懒汉模式的缺点就是，在编码上比饿汉模式复杂，在创建单例对象时需要考虑线程安全的问题
单例场景
在 RPC（Remote Procedure Call，远程过程调用）项目中，单例模式是一种常见的设计模式，用于确保某个类只有一个实例，并提供一个全局访问点。单例模式在 RPC 项目中特别有用，例如用于管理配置、日志记录器或连接池等资源。
例如：在 RPC 项目中使用单例模式来管理一个全局的配置对象
#include <iostream>
#include <mutex>
#include <memory>
class ConfigManager {
private:
// 静态指针，存储唯一的实例
static std::unique_ptr<ConfigManager> instance;
// 私有化构造函数，防止外部直接构造
ConfigManager() {
std::cout << "ConfigManager initialized." << std::endl;
}
// 禁止拷贝构造和赋值操作
ConfigManager(const ConfigManager&) = delete;
ConfigManager& operator=(const ConfigManager&) = delete;
public:
// 提供一个静态方法获取实例
static ConfigManager& getInstance() {
static std::once_flag onceFlag;
std::call_once(onceFlag, []() {
instance = std::make_unique<ConfigManager>();
});
return *instance;
}
// 示例方法：获取配置值
std::string getConfigValue(const std::string& key) {
// 这里可以实现从配置文件或数据库中读取配置
return "value_for_" + key;
}
};
// 初始化静态成员变量
std::unique_ptr<ConfigManager> ConfigManager::instance = nullptr;
使用单例
#include <iostream>
int main() {
// 获取单例实例
ConfigManager& configManager = ConfigManager::getInstance();
// 使用单例实例
std::string value = configManager.getConfigValue("database_url");
std::cout << "Config Value: " << value << std::endl;
return 0;
}
代码理解：
- 私有化构造函数：
ConfigManager()：构造函数被私有化，防止外部直接构造对象。- 禁止拷贝构造和赋值操作，确保类的实例唯一性。
- 静态实例：
static std::unique_ptr<ConfigManager> instance;：静态成员变量，存储唯一的实例。- 使用
std::unique_ptr确保实例在程序结束时自动释放。
- 全局访问点：
static ConfigManager& getInstance()：提供一个静态方法，用于获取唯一的实例。- 使用
std::call_once和std::once_flag确保实例只被初始化一次，即使在多线程环境下也能安全工作。
- 延迟初始化：
- 实例仅在第一次调用
getInstance()时初始化，避免不必要的资源占用。
- 实例仅在第一次调用