问题：在C++17中，如何实现一个线程安全的单例模式？

在 C++17 之前实现线程安全单例通常需要使用双重检查锁（double‑checked locking）或显式同步；但从 C++11 开始，静态局部变量的初始化已经是线程安全的。C++17 进一步简化了单例实现，主要关注点变成了可定制的实例生命周期和避免“野指针”问题。下面给出一种既符合 C++17 标准，又易于维护的实现方式，并说明常见陷阱与最佳实践。

1. 基本实现（最小可行）

#include <mutex>
#include <memory>
#include <iostream>

class MySingleton
{
public:
    // 获取全局实例
    static MySingleton& instance()
    {
        static MySingleton instance;   // C++11 及以后，初始化线程安全
        return instance;
    }

    // 禁止拷贝与移动
    MySingleton(const MySingleton&) = delete;
    MySingleton& operator=(const MySingleton&) = delete;
    MySingleton(MySingleton&&) = delete;
    MySingleton& operator=(MySingleton&&) = delete;

    // 示例方法
    void do_something()
    {
        std::lock_guard<std::mutex> lock(mutex_);
        std::cout << "Doing something, count = " << ++count_ << std::endl;
    }

private:
    MySingleton() = default;   // 构造函数私有，防止外部实例化
    ~MySingleton() = default;  // 析构函数私有，防止外部析构

    std::mutex mutex_;
    int count_ = 0;
};

为什么是线程安全？
C++11 规定，局部静态变量的第一次初始化在多线程情况下只会被某一个线程完成，其余线程会阻塞直到完成。C++17 没有改变这一点，依旧符合标准。

2. 延迟初始化与自定义销毁

如果单例需要在程序结束前进行清理（例如释放非托管资源），可以使用 std::unique_ptr 与 std::atexit：

class MySingleton
{
public:
    static MySingleton& instance()
    {
        static MySingleton* ptr = nullptr;
        if (!ptr) {
            std::call_once(initFlag_, [](){
                ptr = new MySingleton();
                std::atexit([](){ delete ptr; });
            });
        }
        return *ptr;
    }

    // 其余成员同上
private:
    MySingleton() = default;
    ~MySingleton() = default;

    static std::once_flag initFlag_;
};

std::once_flag MySingleton::initFlag_;

std::call_once 保证仅一次初始化。
std::atexit 确保程序结束时正确析构。
这样实现可以让单例拥有显式的生命周期，适用于需要提前销毁的场景。

3. 解决“双重检查锁”陷阱

如果你坚持使用双重检查锁（如在 C++11 以前的代码中），请注意以下两点：

内存屏障：必须使用 std::atomic 或 std::atomic_flag 来标记实例是否已创建。
对象完成：必须等到构造完成后才将指针写入共享变量，否则其它线程可能看到未初始化的成员。

示例：

class MySingleton
{
public:
    static MySingleton* instance()
    {
        MySingleton* tmp = instance_.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            tmp = instance_.load(std::memory_order_relaxed);
            if (!tmp) {
                tmp = new MySingleton();
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }
private:
    MySingleton() = default;
    static std::atomic<MySingleton*> instance_;
    static std::mutex mutex_;
};

std::atomic<MySingleton*> MySingleton::instance_{nullptr};
std::mutex MySingleton::mutex_;

但在 C++17 推荐直接使用局部静态变量，因为它简洁、易读且已被标准保证线程安全。

4. 单例与多线程性能

频繁访问：单例内部的 do_something 使用 std::mutex 保护计数器。若计数器访问非常频繁，可以改用 `std::atomic `，避免锁开销。
读多写少：若单例大部分时间只读，考虑使用读写锁或 std::shared_mutex。
懒加载 vs 预加载：若单例的构造成本高，最好保持懒加载；但如果构造时间短且对性能敏感，直接在 main 开始时实例化可能更好。

5. 常见误区

误区	正确做法
认为局部静态变量在 C++17 仍不安全	C++11 起已保证安全
误用 `delete` 关键字销毁单例	单例由 `std::atexit` 或程序结束时自动销毁
认为 `std::call_once` 只能在全局范围使用	也可在类内部使用，保证一次性初始化
忽略移动构造/赋值导致的错误	明确删除移动语义，防止被误用

6. 小结

在 C++17 中，实现线程安全单例最简单的方式是使用局部静态变量。
如需自定义销毁或更细粒度的控制，可结合 std::call_once 与 std::atexit。
对于高并发访问，考虑使用 std::atomic 或 std::shared_mutex 替代传统 std::mutex。
避免老式的双重检查锁实现，除非你在维护老代码库。