在多线程环境下保证单例模式的线程安全,可以采用以下几种方法:
饿汉式:在程序启动时就创建单例实例,这种方式简单且线程安全,因为实例是在程序启动时创建的,所以不会有线程安全问题。但是它的缺点是不管是否使用实例都会占用资源。
cpp
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
来确保线程安全。
cpp
#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
来保证内存的可见性和防止指令重排。
cpp
#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及以后的版本中,局部静态变量的初始化是线程安全的。因此,可以在一个静态方法中创建一个局部静态变量来实现单例,这种方式既简单又线程安全。
cpp
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
:这是一种线程安全的方式来保证代码只执行一次,通常用于懒汉式的单例模式实现中。
cpp
#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
:通过原子操作来确保只有一个线程可以执行实例创建的代码块。
cpp
#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;