定义
保证一个类仅有一个实例,并提供一个该实例的全局访问点。
——
《设计模式》
GoF
版本一
首先我们来看一个最简单的单例模式实现:
class Singleton {
public:
static Singleton* GetInstance() {
if (_instance == nullptr) {
_instance = new Singleton();
}
return _instance;
}
private:
Singleton() {} //构造
~Singleton() {}
Singleton(const Singleton &clone){} //拷⻉构造
Singleton& operator=(const Singleton&) {}
static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
上面这个版本有什么问题呢?主要有以下问题:1、不支持多线程,2、_instance指向的对象没有释放。然后我们先来解决内存泄漏问题,版本二如下:
版本二
class Singleton {
public:
static Singleton * GetInstance() {
if (_instance == nullptr) {
_instance = new Singleton();
atexit(Destructor);
}
return _instance;
}
~Singleton() {}
private:
static void Destructor() {
if (nullptr != _instance) { //
delete _instance;
_instance = nullptr;
}
}
Singleton();//构造
~Singleton() {}
Singleton(const Singleton &cpy); //拷⻉构造
Singleton& operator=(const Singleton& other) {}
static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
这时我们解决了资源释放的问题,还没有解决多线程问题,接下来我们解决多线程的问题,版本三如下:
版本三
#include <mutex>
class Singleton {
public:
static Singleton * GetInstance() {
// std::lock_guard<std::mutex> lock(_mutex); // 3.1 切换线程
if (_instance == nullptr) {
std::lock_guard<std::mutex> lock(_mutex); // 3.2
if (_instance == nullptr) {
_instance = new Singleton();
atexit(Destructor);
}
}
return _instance;
}
private:
static void Destructor() {
if (nullptr != _instance) {
delete _instance;
_instance = nullptr;
}
}
Singleton(){} //构造
Singleton(const Singleton &cpy){} //拷⻉构造
Singleton& operator=(const Singleton&) {}
static Singleton * _instance;
static std::mutex _mutex;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化
版本三还存在问题没?主要是还没有考虑到CPU的reorder操作。所以我们用内存屏障来解决这个问题,版本四如下:
版本四
#include <mutex>
#include <atomic>
class Singleton {
public:
static Singleton * GetInstance() {
Singleton* tmp = _instance.load(std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_acquire);//获取内存屏障
if (tmp == nullptr) {
std::lock_guard<std::mutex> lock(_mutex);
tmp = _instance.load(std::memory_order_relaxed);
if (tmp == nullptr) {
tmp = new Singleton;
std::atomic_thread_fence(std::memory_order_release);//释放内存屏障
_instance.store(tmp, std::memory_order_relaxed);
atexit(Destructor);
}
}
return tmp;
}
private:
static void Destructor() {
Singleton* tmp = _instance.load(std::memory_order_relaxed);
if (nullptr != tmp) {
delete tmp;
}
}
Singleton(){}
Singleton(const Singleton&) {}
Singleton& operator=(const Singleton&) {}
static std::atomic<Singleton*> _instance;
static std::mutex _mutex;
};
std::atomic<Singleton*> Singleton::_instance;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化
接下来,我们来学习一下c++ effective里面提供的一个版本,版本五如下:
版本五
class Singleton
{
public:
static Singleton& GetInstance() {
static Singleton instance;
return instance;
}
private:
Singleton(){}
~Singleton() {}
Singleton(const Singleton&) {}
Singleton& operator=(const Singleton&) {}
};
该版本简洁的难以置信,大牛就是大牛,作者巧妙应用了c++11 magic static
特性:如果当变量在初始化的时候,并发同时进
入声明语句,并发线程将会阻塞等待初始化结束,但是有一个缺点,如果项目里面有多个单例,就无法使用了。然后我们用模板和继承来实现一个更方便使用的版本,版本六如下:
版本六
template<typename T>
class Singleton {
public:
static T& GetInstance() {
static T instance; // 这里要初始化DesignPattern,需要调用DesignPattern构造函数,同时会调用父类的构造函数。
return instance;
}
protected:
virtual ~Singleton() {}
Singleton() {} // protected修饰构造函数,才能让子类继承
Singleton(const Singleton&) {}
Singleton& operator =(const Singleton&) {}
};
class DesignPattern : public Singleton<DesignPattern> {
friend class Singleton<DesignPattern>; // friend 能让Singleton<T> 访问到DesignPattern构造函数
public:
~DesignPattern() {}
private:
DesignPattern() {}
DesignPattern(const DesignPattern&) {}
DesignPattern& operator=(const DesignPattern&) {}
};
总结
通过从最简单的版本不停迭代,最后得到一个很不错的版本,具有以下优点:
1. 利用静态局部变量特性,延迟加载;
2. 利用静态局部变量特性,系统自动回收内存,自动调用析构函数;
3. 静态局部变量初始化时,没有 new 操作带来的cpu指令reorder操作;
4. c++11 静态局部变量初始化时,具备线程安全。