更多设计模式参看: 设计模式之模式概述(模式汇总)(C++实现)
文章目录
介绍
涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
意图:
单例模式(Singleton Pattern): 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。单例模式是一种对象创建型模式。
解决问题:
一个全局使用的类频繁地创建与销毁。
实现概述:
构造函数是私有的,避免外部通过 new 创建实例。 getInstance() 判断系统是否已经有这个单例,如果有则返回,如果没有则创建。
要点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例
应用场景:
(1) 系统只需要一个实例对象,比如,配置信息类,如系统要求提供一个唯一的序列号生成器或资源管理器,或者需要考虑资源消耗太大而只允许创建一个对象。
(2) 客户调用类的单个实例只允许使用一个公共访问点,除了该公共访问点,不能通过其他途径访问该实例。
生活中场景
Windows任务管理器只能启动一个
软件中场景
负载均衡器,配置信息类等
优点:
- 在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
- 避免对资源的多重占用(比如写文件操作)。
缺点:
- 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
模式结构
角色
单例模式是结构最简单的设计模式一,在它的核心结构中只包含一个被称为单例类的特殊类。(下图为单例模式懒汉式结构图)
类图
代码示例
饿汉式
只有在第一次用到类实例的时候才实例化。不过,这样的实现方式不支持延迟加载。
由于是一个static对象,可以保证对象只生成一次,线程安全的。
GitHub
饿汉式单例类
class EagerSingleton {
public:
static EagerSingleton *getInstance(){
return instance;
}
static void delInstance() {
if(instance != nullptr) {
delete instance;
instance = nullptr;
}
}
private:
EagerSingleton(){
std::cout << "EagerSingleton Hello" << std::endl;
};
~EagerSingleton() { // 私有化 可以避免 直接 delete s1 ,必须 使用 delInstance
std::cout << "EagerSingleton Bye" << std::endl;
}
// static对象,可以保证对象只生成一次,并且是多线程安全
static EagerSingleton *instance;
};
// 饿汉模式的关键:初始化即实例化
EagerSingleton *EagerSingleton::instance = new EagerSingleton();
测试
int main() {
EagerSingleton *s1 = EagerSingleton::getInstance();
EagerSingleton *s2 = EagerSingleton::getInstance();
std::cout << "s1 address = " << s1 << std::endl;
std::cout << "s2 address = " << s2 << std::endl;
EagerSingleton::delInstance();
getchar();
return 0;
}
输出
懒汉式
懒汉式单例在第一次调用getInstance()方法时实例化,在类加载时并不自行实例化,这种技术又称为**延迟加载*(Lazy Load)***技术,即需要的时候再加载实例,为了避免多个线程同时调用getInstance()方法,我们可以使用锁或者static变量
GitHub
懒汉式单例类+双检查锁: LazySingleton01
懒汉式单例类+static变量: LazySingleton02
懒汉式单例类+双检查锁
class LazySingleton {
public:
static LazySingleton *getInstance() {
//第一个检查,如果只是读操作,就不许用加锁
if (instance == nullptr) {
std::lock_guard<std::mutex> lck(m_mutex);
//第二个检查,保证只有一个
if (instance == nullptr) {
instance = new LazySingleton;
}
}
return instance;
}
static void delInstance() {
if(instance != nullptr) {
delete instance;
instance = nullptr;
}
}
private:
LazySingleton(){
std::cout << "LazySingleton Hello" << std::endl;
};
~LazySingleton() { // 私有化 可以避免 直接 delete s1 ,必须 使用 delInstance
std::cout << "LazySingleton Bye" << std::endl;
}
static LazySingleton *instance;
static std::mutex m_mutex;
};
LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::m_mutex;
懒汉式单例类+static变量
class LazySingleton {
public:
static LazySingleton *getInstance() {
static LazySingleton instance;
return &instance;
}
private:
LazySingleton(){
std::cout << "LazySingleton Hello" << std::endl;
};
~LazySingleton() { // 私有化 可以避免 直接 delete s1 ,必须 使用 delInstance
std::cout << "LazySingleton Bye" << std::endl;
}
};
1、C++11中可以保证static变量时多线程安全的,在底层实现了加锁操作,所以不需要像以前那样自己写加锁操作。
2、由于是一个static对象,可以保证对象只生成一次;
3、在程序结束的时候,系统会调用对应的析构函数;如果是new出来的对象,程序结束的时候,系统不会自动调用析构函数。
测试
懒汉式单例类+双检查锁
int main() {
LazySingleton *s1 = LazySingleton::getInstance();
LazySingleton *s2 = LazySingleton::getInstance();
std::cout << "s1 address = " << s1 << std::endl;
std::cout << "s2 address = " << s2 << std::endl;
LazySingleton::delInstance();
getchar();
return 0;
}
懒汉式单例类+static变量
int main() {
LazySingleton *s1 = LazySingleton::getInstance();
LazySingleton *s2 = LazySingleton::getInstance();
std::cout << "s1 address = " << s1 << std::endl;
std::cout << "s2 address = " << s2 << std::endl;
getchar();
return 0;
}
输出
懒汉式单例类+双检查锁
懒汉式单例类+static变量
个人能力有限,如有错误之处或者其他建议,敬请告知欢迎探讨,谢谢!