【重学C++】【设计模式】深入总结单例模式：各种实现方法与跨so场景下的可行性

同学小张

已于 2024-05-22 10:04:54 修改

阅读量973

点赞数 18

分类专栏：重学C++ 文章标签： c++ 设计模式单例模式开发语言笔记经验分享

于 2024-05-16 07:00:00 首次发布

本文链接：https://blog.csdn.net/Attitude93/article/details/138609692

版权

重学C++ 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

大家好，我是同学小张，持续学习C++进阶知识和AI大模型应用实战案例，持续分享，欢迎大家点赞+关注，共同学习和进步。

重学C++系列文章，在会用的基础上深入探讨底层原理和实现，适合有一定C++基础，想在C++方向上持续学习和进阶的同学。争取让你每天用5-10分钟，了解一些以前没有注意到的细节。

单例模式是最简单的设计模式之一，也是项目中最常用的模式之一，一定要会！本文我们就来学习下单例模式。

0. 什么是单例模式、使用场景

单例模式核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。

使用场景：

（1）共享资源：当需要在多个组件或模块间共享资源时，如共享数据库连接、共享配置文件等。

（2）控制资源数量：当需要严格限制资源数量时，如线程池、缓存、日志记录器等。

（3）独立配置：需要全局配置时，如应用程序的全局设置。

（4）系统状态：表示整个系统的状态，如用户会话管理。

（5）资源池：如数据库连接池、线程池等，需要限制数量并进行统一管理。

1. 单例模式的实现方式

在C++中，实现单例模式有多种方法，每种方法都有其特定的使用场景和优缺点。

1.1 懒汉式

1.1.1 实现代码

class Singleton {
private:
    static Singleton* instance;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    Singleton(Singleton const&) = delete;
    void operator=(Singleton const&) = delete;

private:
    Singleton() {}
};
// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

1.1.2 优点

实现简单，延迟初始化，只有在第一次调用getInstance时才创建实例。

1.1.3 缺点

线程不安全，多线程环境下可能产生多个实例。

1.1.4 改进

上面的懒汉式实现存在线程不安全的问题，我们可以使用锁来保证线程安全。

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;

public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    Singleton(Singleton const&) = delete;
    void operator=(Singleton const&) = delete;

private:
    Singleton() {}
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

这样就实现了线程安全，通过互斥锁保证了只有一个线程可以创建实例。但是由于互斥锁的存在，可能会影响性能，尤其是在高并发场景下。

1.2 饿汉式

因为静态变量在类加载时就被初始化，所以饿汉式在程序启动时就创建了实例。

1.2.1 实现代码

class Singleton {
private:
    static Singleton instance;

public:
    static Singleton& getInstance() {
        return instance;
    }

    Singleton(const Singleton&) = delete;
    void operator=(const Singleton&) = delete;

private:
    Singleton() {}
};

1.2.2 优点

线程安全，因为实例在程序启动时就已经创建。
避免了懒汉式中的延迟初始化问题。

1.2.3 缺点

实例在程序启动时就创建，不管是否被使用，可能导致资源浪费，拖慢启动速度。

1.3 局部静态变量

1.3.1 实现代码

#include <iostream>

class Singleton {
public:
    // 提供全局访问点
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量
        return instance;
    }

    // 私有化拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 如果需要，可以添加一个销毁单例的静态方法
    static void destroyInstance() {
        delete &getInstance();
    }

    // 如果需要序列化，可以添加相应的方法
    // ...

private:
    // 私有化构造函数
    Singleton() {}

private:
    // 其他私有成员和方法
};

1.3.2 优点

线程安全，局部静态变量的初始化是线程安全的。
延迟初始化，只有在第一次调用getInstance时才创建实例。

1.3.3 缺点

相对于饿汉式，代码稍微复杂一些。

1.4 使用C++11标准库中的std::call_once和std::once_flag

1.4.1 实现代码

#include <mutex>

class Singleton {
private:
    static std::once_flag once;
    static Singleton* instance;

public:
    static Singleton& getInstance() {
        std::call_once(once, []() {
            instance = new Singleton();
        });
        return *instance;
    }

    Singleton(Singleton const&) = delete;
    void operator=(Singleton const&) = delete;

private:
    Singleton() {}
};

std::once_flag Singleton::once;
Singleton* Singleton::instance = nullptr;

1.4.2 优点

线程安全，使用C++11标准库中的互斥机制。
性能可能比使用std::mutex更好，因为std::call_once只在第一次调用时锁定。

1.4.3 缺点

需要C++11支持。

如果不需要考虑多线程，可以选择懒汉式。

2. 跨so的单例模式

在跨动态链接库的情况下，以上有些方法实现不了单例模式。 这是非常容易忽略和犯错的地方。一旦出现，很难排查。

动态链接库（SO）是允许程序在运行时加载和卸载的模块，它们可以被多个程序共享。在这种情况下，每个SO都可能尝试创建单例，从而导致多个实例的存在。

2.1 上述创建方式在跨SO场景下的可行性

懒汉式（线程不安全）：在跨SO的情况下，这种方法不适用，因为每个SO中的getInstance方法都可能独立地创建一个实例。
懒汉式（线程安全，加锁的改进版）：虽然使用互斥锁可以确保线程安全，但它并不能保证在跨SO的情况下只创建一个实例。每个SO中的getInstance方法仍然可能创建自己的实例。
饿汉式：这种方法在理论上可以工作，因为如果实例在程序启动时就已经创建，那么所有SO共享的是同一个实例。但是，这要求所有SO都必须链接到同一个饿汉式单例的实现，否则每个SO中都会有自己的实例。
局部静态变量：这是在跨SO情况下实现单例模式的常用方法。局部静态变量的初始化在C++中是线程安全的，并且只会在首次访问时进行。因此，只要所有SO都使用相同的getInstance方法，就可以保证只创建一个实例。
使用C++11标准库中的std::call_once和std::once_flag：这种方法也可以在跨SO的情况下工作，原理与局部静态变量类似。它利用了C++11标准库中的线程安全机制来确保只创建一个实例。