C++单例模式在多线程环境下如何保证线程安全？

在多线程环境下保证单例模式的线程安全，可以采用以下几种方法：

饿汉式：在程序启动时就创建单例实例，这种方式简单且线程安全，因为实例是在程序启动时创建的，所以不会有线程安全问题。但是它的缺点是不管是否使用实例都会占用资源。

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

private:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton instance;
};

// 在类外初始化静态成员变量
Singleton Singleton::instance;

懒汉式：在第一次使用时才创建实例，这种方式需要额外的同步机制来保证线程安全。可以通过加锁（互斥锁）来实现，例如使用std::mutex和std::lock_guard来确保线程安全。

#include <mutex>

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

private:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* instance;
};

// 在类外初始化静态成员指针
Singleton* Singleton::instance = nullptr;

双重检查锁定（Double-Checked Locking）：在获取实例的方法中，先检查实例是否已经创建，如果未创建则加锁并再次检查，这样可以减少锁的开销。但是这种方式需要配合std::atomic来保证内存的可见性和防止指令重排。

#include <atomic>

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

private:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::atomic<Singleton*> instance;
    static std::mutex mutex;
};

// 在类外初始化静态成员变量
std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;

局部静态变量：在C++11及以后的版本中，局部静态变量的初始化是线程安全的。因此，可以在一个静态方法中创建一个局部静态变量来实现单例，这种方式既简单又线程安全。

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

private:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

使用std::call_once：这是一种线程安全的方式来保证代码只执行一次，通常用于懒汉式的单例模式实现中。

#include <mutex>

class Singleton {
public:
    static Singleton& getInstance() {
        static std::once_flag onceFlag;
        std::call_once(onceFlag, &Singleton::initInstance);
        return *_instance;
    }

private:
    static void initInstance() {
        _instance = new Singleton();
    }

    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* _instance;
    static std::once_flag onceFlag;
};

// 在类外初始化静态成员变量和once_flag
Singleton* Singleton::_instance = nullptr;
std::once_flag Singleton::onceFlag;

使用std::atomic和std::mutex：通过原子操作来确保只有一个线程可以执行实例创建的代码块。

#include <atomic>
#include <mutex>

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

private:
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::atomic<Singleton*> instance;
    static std::mutex mutex;
};

// 在类外初始化静态成员变量
std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;