在GOF《设计模式》中,单例模式的定义为——保证一个类仅有一个实例,并提供一个该实例的全局访问点。
下面是单例模式的c++实现:
方案一:
(构造函数和拷贝构造函数一定要声明为private;定义static成员:单例指针和获取单例指针的函数;static单例指针要在类外定义并初始化;实现获取单例指针的函数时要注意线程安全的问题)
class Singleton {
private:
Singleton();
Singleton(const Singleton& other);
static Singleton* m_instance;
public:
static Singleton* getInstance();
};
Singleton* Singleton::m_instance = nullptr;
//线程非安全版本
Singleton* Singleton::getInstance() {
if (m_instance == nullptr) {
m_instance = new Singleton();
}
return m_instance;
}
//线程安全版本,但锁的代价过高,高并发时不能用该版本
Singleton* Singleton::getInstance() {
Lock lock;
if (m_instance == nullptr) {
m_instance = new Singleton();
}
return m_instance;
}
//双检查锁,但由于内存读写reorder不安全,所以该版本也是线程非安全的
Singleton* Singleton::getInstance() {
if (m_instance == nullptr) {
Lock lock;
if (m_instance == nullptr) {
m_instance = new Singleton();
}
}
return m_instance;
}
//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;
Singleton* Singleton::getInstance() {
Singleton* tmp = m_instance.load(std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
if (tmp == nullptr) {
std::lock_guard<std::mutex> lock(m_mutex);
tmp = m_instance.load(std::memory_order_relaxed);
if (tmp == nullptr) {
tmp = new Singleton;
std::atomic_thread_fence(std::memory_order_release);//释放内存fence
m_instance.store(tmp, std::memory_order_relaxed);
}
}
return tmp;
}
方案二:
(根据Effective C++ 条款04改写,有待进一步检验是否可行)
class Singleton {
private:
Singleton() {}
Singleton(const Singleton&);
public:
static Singleton* getSingleton();
};
//非线程安全
Singleton* Singleton::getSingleton() {
static Singleton s;
return &s;
}