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

文章目录

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

      什么是单例模式

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

      
      （图片来源网络，侵删）

      饿汉实现方式

      观察下面代码：

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

        上面加锁方式在每次调用getInstance()这个函数的时候都会加一次锁，频繁的调用该函数可能会造成一定的性能问题。

        对于上面加锁方式还可以进一步进行优化，例如采用双重检查锁定，具体优化的代码如下：

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

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

        懒汉实现方式的特点

        • 线程不安全
        • 延迟实例化
        • 需要使用互斥锁保证线程安全

          具体原因分析上面已经阐述过了，这里就不做过多分析了。