一、单例模式

定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。

单例模式很容易写，但是保证多线程安全的单例模式则不容易。

代码

版本1

// 内存栈区
// 内存堆区
// 常数区
// 静态区 系统释放 
// 二进制代码区 
class Singleton {
public:
  static Singleton * GetInstance() {
    if (_instance == nullptr) {
      _instance = new Singleton();
}
    return _instance;
  }
private:
Singleton(){}//构造
Singleton(const Singleton &clone){} //拷⻉构造 Singleton& operator=(const Singleton&) {} static Singleton * _instance;
}
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

版本2

 
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(const Singleton &cpy); //拷⻉构造 Singleton& operator=(const Singleton&) {} static Singleton * _instance;
}
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化 // 还可以使用 内部类，智能指针来解决; 此时还有线程安全问题

版本3

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

版本4

   
#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) {
障
}
return tmp; }
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

版本5

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

如果想要可继承，就需要写成版本6的样子：

版本5

 
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构造函数
private:
  DesignPattern(){}
  DesignPattern(const DesignPattern&) {}
  DesignPattern& operator=(const DesignPattern&) {}
}
 

1-3都是一个懒汉模式，需要用到的时候才会进行初始化。

以上版本，除了版本5和版本6之外，几乎都有一定的多线程安全问题。其中，版本1 内存泄漏，多线程不安全；版本2 解决了内存泄漏；版本3 加了互斥锁，但是粒度太大了。会切换线程，代价高；下沉之后，加上double lock之后还是有问题，cpu指令如果重排，就会有问题，指针没有调用构造器，有值但是都是随机的，访问就出错了。或者用pthread_once也是可以的。

版本4通过内存屏障解决了内存重排的问题。但是写法也比较复杂。