设计模式（二）

六、单例模式

定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。 ——《设计模式》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;//静态成员需要初始化
 

 

版本一中，_instance对象是指针静态对象，存储在全局数据区，指针指向的对象空间是通过new得到的，在堆区。在此版本中，在堆区创建了对象，但是没有手动释放，造成了内存泄漏。

版本二

// 类对象之间 友元
class Singleton {
public:
　　static Singleton * GetInstance() {
　　　　if (_instance == nullptr) {
　　　　　　_instance = new Singleton();
　　　　　　atexit(Destructor);
　　}
　　return _instance;
　　}12 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;//静态成员需要初始化
// 还可以使⽤ 内部类，智能指针来解决； 此时还有线程安全问题
 

版本二使用atexit（）函数解决了进程退出后单例中堆内存的释放问题。除了用这种解决方法，我们还可以将new换成智能指针或者内部类的实现了避免手动创建和释放堆内存。但是，在这两个版本中我们都没有考虑多线程临界资源问题。

版本三

#include <mutex>
class Singleton { // 懒汉模式 lazy load
public:
　　static Singleton * GetInstance() {
　　　　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; //互斥锁初始化

版本三使用了互斥锁完成了对临界资源的保护，同时，使用双重判断指针是否为空，防止出现在第一次判空后指针被其他线程赋值后本线程再次赋值的重复操作。

对于new操作，一共有三个顺序步骤

1. 分配内存
2. 调用构造函数
3. 返回指针

在多线程环境下，cpu会可能会执行reorder进行优化，即先分配内存，然后就返回指针，最后再调用构造函数。在这种情况下，可能会导致其他线程得到的指针是一个野指针。

版本四

// volitile关键字 在java中有内存屏障的作用，在C++中没有
#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; //互斥锁初始化
// g++ Singleton.cpp -o singleton -std=c++11

版本四中使用原子库来实现对_instance对象的new过程的内存屏障。

版本五

// c++11 magic static 特性：如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将会阻塞等待初始化结束。
// c++ effective的作者写的一个单例版本
class Singleton
{
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton(){}
    ~Singleton() {}
    Singleton(const Singleton&) {}
    Singleton& operator=(const Singleton&) {}
};
// g++ Singleton.cpp -o singleton -std=c++11
/*该版本具备的优点：
1. 利⽤静态局部变量特性，延迟加载；
2. 利⽤静态局部变量特性，系统⾃动回收内存，⾃动调⽤析构函数；
3. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作；
4. c++11 静态局部变量初始化时，具备线程安全；
*/      
   

版本五是一个常用版本，但是，单例对象的类型被写死了。

版本六

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&) {}
};
 

版本六将单例对象的类型抽象了出来，使得对象类型可变。

结构图

 

------------------------------------------------------------------------------------------------------------------------

github：https://github.com/illusorycat/Design-patterns.git