设计模式——单例模式（c++）

在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;
}