从C++单例模式到线程安全详解

什么是单例模式

单例模式是一种设计模式，它允许一个类只创建一个实例，同时提供一个访问该实例的全局节点。这种模式常用于控制特定资源的访问，如数据库或者网络连接。

C++实现单例模式

在C++中，实现单例模式最常用的方法是使用静态成员变量和私有构造函数。具体实现步骤如下：
1. 将类的构造函数设置为私有。
2. 在类中定义一个静态私有成员变量，用于存储唯一实例。
3. 提供一个静态公有方法用于获取该唯一实例，如果唯一实例未创建，则先创建并返回该实例。

下面是一个简单的示例代码：

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

private:
    Singleton() {} // 禁止外部调用构造函数
    ~Singleton() {}
    Singleton(const Singleton&) = delete; // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值构造函数
};

单例模式的线程安全问题

在单线程环境下，上述实现单例模式方法是可行的。然而，在多线程环境下，上述实现会存在线程安全问题。

例如，当有多个线程同时调用getInstance()方法时，会导致创建多个实例。这违反了单例模式的定义。

解决单例模式线程安全问题的方法

想要解决单例模式的线程安全问题，需要实现双重锁定。

具体实现步骤如下：
1. 将类的构造函数设置为私有。
2. 在类中定义一个静态私有成员变量，用于存储唯一实例。
3. 提供一个静态公有方法用于获取该唯一实例，并使用双重锁定确保线程安全。

下面是一个示例代码：

#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 Singleton* instance_; // 静态成员变量
    static std::mutex mutex_; // 互斥锁
};

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mutex_;

在这个示例代码中，我们使用了std::mutex类型的互斥锁来保证线程安全。当getInstance()方法被第一个线程调用时，会获取到互斥锁，接着检查实例是否为空。如果为空，则创建一个新的实例，并将其赋值给instance_。最后，返回该实例。

示例说明

下面提供两个示例说明。

示例1：多线程输出单例模式的唯一实例

下面是一个多线程输出单例模式的唯一实例的示例代码：

#include <iostream>
#include <thread>

void printInstance(int tid) {
    auto& instance = Singleton::getInstance();
    std::cout << "Thread ID: " << tid << " Singleton instance address: " << &instance << std::endl;
}

int main() {
    std::thread t1(printInstance, 1);
    std::thread t2(printInstance, 2);
    std::thread t3(printInstance, 3);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

在这个示例代码中，我们定义了一个输出单例模式唯一实例地址的函数printInstance()，并分别启动了3个线程来调用该函数。通过查看输出结果，可以发现3个线程输出的唯一实例地址相同，表明单例模式的确实现了实例的唯一性。

示例2：单例模式的线程安全问题

下面是一个多线程创建单例实例的示例代码：

#include <iostream>
#include <thread>

void createInstance(int tid) {
    // 由于没有双重锁定，线程会创建多个实例
    auto& instance = Singleton::getInstance();
    std::cout << "Thread ID: " << tid << " Singleton instance address: " << &instance << std::endl;
}

int main() {
    std::thread t1(createInstance, 1);
    std::thread t2(createInstance, 2);
    std::thread t3(createInstance, 3);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

在这个示例代码中，我们定义了一个创建单例实例的函数createInstance()，并分别启动了3个线程来调用该函数。通过查看输出结果，可以发现3个线程创建的实例地址不同，表明单例模式存在线程安全问题。

总结

单例模式是一种常用的设计模式，可以保证程序中某些资源的唯一性。在多线程环境中，为了解决单例模式的线程安全问题，需要使用双重锁定的方法。