欢迎来到尧图网

客户服务 关于我们

您的位置:首页 > 科技 > 能源 > 【多线程】线程安全的单例模式

【多线程】线程安全的单例模式

2025/2/25 2:57:35 来源:https://blog.csdn.net/qq_62987647/article/details/140489272  浏览:    关键词:【多线程】线程安全的单例模式

文章目录

  • 什么是单例模式
    • 饿汉实现方式
      • 饿汉实现模式的特点
    • 懒汉实现方式
    • 懒汉实现方式的特点

什么是单例模式

单例模式是一个设计模式,其目的是确保一个类只有一个实例,并提供一个全局的访问点来访问该实例。单例模式常用于需要控制资源数量的场景,比如数据库连接池、日志管理器等。下面介绍常见的单例模式的实现方式。

饿汉实现方式

观察下面代码:

class EagerSingleton {
private:// 私有构造函数,防止外部实例化EagerSingleton() {}// 禁用拷贝构造函数和赋值运算符EagerSingleton(const EagerSingleton&) = delete;EagerSingleton& operator=(const EagerSingleton&) = delete;// 静态实例,类加载时初始化static EagerSingleton instance;public:// 提供全局访问点static EagerSingleton& getInstance() {return instance;}
};// 初始化静态实例
EagerSingleton EagerSingleton::instance;

要想实现单例,从两个方面入手:1.如何实现禁止构造2个或者2个以上的实例化对象。2.如何实现只构造一个对象
对于前者,我们可以将构造函数私有化,这样就不能在类外部构造对象了。那怎么保证拥有一个实例化对象呢?这一点可以在类中使用static修饰一个该类的实例对象,这样就能在程序加载的时候自动创建一个实例化对象,由于static成员属于类本身的特性,所以能使用私有的构造函数,且只会加载一次。

要想使用这个单例,就需要一个static修饰的成员方法专门用来提供全局的访问点,因为static成员函数可以直接通过类名使用,不需要创建实例化对象。 此外静态成员变量需要在类外部初始化

饿汉实现模式的特点

  • 类加载的时候实例化
  • 私有化构造函数
  • 线程安全由于实例化是在类加载的时候完成的,且类加载的过程中由C++标准保证了线程安全,因此不需要额外的同步机制来保证线程安全。

懒汉实现方式

观察下面代码

class LazySingleton {
private:// 私有的静态指针变量,用于指向唯一的实例static LazySingleton* instance;// 私有构造函数,防止外部实例化LazySingleton() {}public:// 提供全局访问点static LazySingleton* getInstance() {if (instance == nullptr) {instance = new LazySingleton();}return instance;}
};// 初始化静态指针变量
LazySingleton* LazySingleton::instance = nullptr;

注意其中和饿汉实现方式的区别,懒汉实现单例模式中static修饰的是一个实例对象的指针。这样一来,类加载的时候就不会构造自动一个实例化对象。具体的观察这一段代码:

static LazySingleton* getInstance() {if (instance == nullptr) {instance = new LazySingleton();}return instance;}

这一段代码保证了该类只能实例化对象一次,且只在第一次调用getInstance() 函数时才会创建。这样一来也能实现单例模式。但是和饿汉模式不一样的是,这种单例模式只在第一次使用的时候实例化一个对象,而饿汉模式是程序开始时不管你用不用都会实例化一个。这种机制又被称为延迟实例化机制。此外,这种机制在多线程模式下是不安全的。比如可能会有多个线程
new LazySingleton();
为了保证线程安全,我们需要使用锁来保证创建实例化对象时同步。例如下面代码:

#include <mutex>class LazySingleton {
private:static LazySingleton* instance;static std::mutex mtx;LazySingleton() {}public:static LazySingleton* getInstance() {std::lock_guard<std::mutex> lock(mtx);if (instance == nullptr) {instance = new LazySingleton();}return instance;}
};// 初始化静态变量
LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::mtx;

上面加锁方式在每次调用getInstance()这个函数的时候都会加一次锁,频繁的调用该函数可能会造成一定的性能问题。
对于上面加锁方式还可以进一步进行优化,例如采用双重检查锁定,具体优化的代码如下:

#include <mutex>class LazySingleton {
private:static LazySingleton* instance;static std::mutex mtx;LazySingleton() {}public:static LazySingleton* getInstance() {if (instance == nullptr) {std::lock_guard<std::mutex> lock(mtx);if (instance == nullptr) {instance = new LazySingleton();}}return instance;}
};// 初始化静态变量
LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::mtx;

这样一来,只有在首次创建对象时会上锁,其余时候都不会也不需要。

懒汉实现方式的特点

  • 线程不安全
  • 延迟实例化
  • 需要使用互斥锁保证线程安全
    具体原因分析上面已经阐述过了,这里就不做过多分析了。

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

热搜词