文章目录
前言
创建型模式主要关注对象的创建过程,提供了一种创建对象的最佳方式,并隐藏了创建逻辑的细节。本章介绍创建型模式中的单例模式。
设计模式详解
3.单例模式(Singleton)
问题
在某些情况下,需要确保一个类只有一个实例,并且需要一个全局访问点来访问这个实例。例如,在一个应用程序中,一个配置管理器类需要保持一致的配置数据,以避免不同部分之间的配置冲突。
解决方案
单例模式特点是只提供唯一一个类的实例,它具有全局变量的特点,可以保证为一个类只生成唯一的实例对象(因为构造函数被私有化了,外部无法创建新的对象),在任何位置都可以通过接口获取到那个唯一实例对象。
应用场景
在应用系统开发中,我们常常有以下需求:
1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多,但又经常用到的对象。
4.方便资源相互通信的环境
例如:多线程中网络资源初始化,回收站机制,任务管理器,应用程序日志管理…
实现代码
1. 懒汉式单例模式
适用于访问量较小,或实例较大的情况。
//懒汉式
#include <iostream>
using namespace std;
class SingleTon {
private:
SingleTon();
//禁用拷贝构造和赋值重载
Singleton(const Singleton&) = delete;//C++11中,定义成员函数,可在后面使用 = delete修饰,表示该函数被删除,禁用;
Singleton& operator=(const Singleton&) = delete;
public:
static SingleTon* m_singleTon;
static SingleTon* GetInstance();
void TestPrint();
};
//懒汉式并不直接创建单例对象
SingleTon* SingleTon::m_singleTon = NULL;
SingleTon::SingleTon() {
m_singleTon = NULL;
cout << "是我!" << endl;
}
SingleTon* SingleTon::GetInstance() {
if (m_singleTon == NULL) {
m_singleTon = new SingleTon;
}
else {
cout << "还是我!" << endl;
}
return m_singleTon;
}
void SingleTon::TestPrint(){
cout << "还是我!" << endl;
}
int main() {
SingleTon* p1 = SingleTon::GetInstance();
SingleTon* p2 = SingleTon::GetInstance();
cout << "p1:" << hex << p1 << endl;
cout << "p2:" << hex << p2 << endl;
p1->TestPrint();
p2->TestPrint();
return 0;
}
运行结果
懒汉式线程不安全: 如果线程a和b同时调用GetInstance方法,在线程a创建对象还没修改m_singleTon变量时,线程b判断m_singleTon为空,也会走到创建对象的代码中,最后导致其中一个对象被覆盖。
为了保证线程安全,单例模式有了以下的写法:
2. 加锁的懒汉式单例模式
使用线程锁保证线程安全。
//加锁的懒汉式
#include <iostream>
#include <mutex>
using namespace std;
class Singleton {
public:
static Singleton*& GetInstance();
void Print() {
std::cout << "我的实例内存地址是:" << this << std::endl;
}
private:
Singleton() {
std::cout << "构造函数" << std::endl;
}
Singleton(const Singleton& signal);
const Singleton& operator=(const Singleton& signal);
private:
static Singleton* m_SingleInstance;
static std::mutex m_Mutex;
};
//初始化静态成员变量
Singleton* Singleton::m_SingleInstance = NULL;
std::mutex Singleton::m_Mutex;
Singleton*& Singleton::GetInstance() {
// 这里使用了两个 if判断语句的技术称为双检锁;好处是,只有判断指针为空的时候才加锁,
// 避免每次调用 GetInstance的方法都加锁,锁的开销毕竟还是有点大的。
if (m_SingleInstance == NULL) {
std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
if (m_SingleInstance == NULL) {
m_SingleInstance = new (std::nothrow) Singleton;
}
}
return m_SingleInstance;
}
int main() {
Singleton* p1 = Singleton::GetInstance();
p1->Print();
Singleton* p2 = Singleton::GetInstance();
p2->Print();
Singleton* p3 = Singleton::GetInstance();
p3->Print();
return 0;
}
3. 饿汉式单例模式
在程序运行前就完成单例的初始化,天生不存在线程问题。但是提前初始化单例,如果实例较大,会导致程序启动较慢;如果很久都用不上,实例还是会一直存在,占用大量的空间。适用于访问量较大或线程较多的情况。
//饿汉式
#include <iostream>
using namespace std;
class Singleton {
public:
static Singleton* GetInstance() {
return &instance;
}
void Print() {
cout << m_num << endl;
}
int m_num;
private:
Singleton(int num) { //1.构造函数私有化
m_num = num;
cout << "是我" << endl;
}
static Singleton instance; //2.定义一个唯一的类的实例对象
};
// 它是类内的成员,所以能访问私有构造函数,此时调用构造函数
Singleton Singleton::instance(2);// 类的静态成员变量要类外初始化,要写在main函数之前,保证程序运行时已经构造好了对象
int main() {
Singleton* p1 = Singleton::GetInstance();
p1->Print();
Singleton* p2 = Singleton::GetInstance();
p2->m_num = 5;
Singleton* p3 = Singleton::GetInstance();
p3->Print();
return 0;
}
4. 静态内部变量(c++11)
使用静态内部变量实现懒汉式,使用c++11的特性,线程安全且代码量较少,推荐。
//静态内部变量实现的懒汉式
#include <iostream>
using namespace std;
class Singleton {
public:
static Singleton& GetInstance() {
static Singleton instance;
return instance;
}
Singleton(Singleton const&) = delete;
void operator=(Singleton const&) = delete;
void Print() {
cout << m_num << endl;
}
int m_num;
private:
Singleton() {}
};
5. call_once实现懒汉单例
使用c++11的std::call_once实现的懒汉单例,call_once保证可调用对象_Fx只被执行一次,即使在多线程场景,函数原型:
template<class _Fn, class... _Args> inline
void (call_once)(once_flag& _Flag, _Fn&& _Fx, _Args&&... _Ax)
其中:
- _Flag:标志对象,用于指示 _Fx 是否已调用过
- _Fx:可调用对象
- _Ax:传递的参数
//call_once实现懒汉单例
#include <iostream>
#include <memory>
#include <mutex>
class Singleton {
public:
static std::shared_ptr<Singleton> GetSingleton();
void Print() {
std::cout << "Hello World." << std::endl;
}
~Singleton() {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
private:
Singleton() {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
static std::shared_ptr<Singleton> singleton = nullptr;
static std::once_flag singletonFlag;
std::shared_ptr<Singleton> Singleton::GetSingleton() {
std::call_once(singletonFlag, [&] {
singleton = std::shared_ptr<Singleton>(new Singleton());
});
return singleton;
}
call_once方法代码的原文链接:
https://blog.csdn.net/unonoi/article/details/121138176
…
To be continued.