定义
保证一个类仅有一个实例，并提供一个该实例的全局访问点。
——
《设计模式》
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.资源释放的问题，由于_instance的内存在全局内存空间，会在进程消亡时候进行释放，当其指向的内存空间是通过new 申请的，如果没有delete，析构是不会调用，从而内存或其他资源是没有时机进行释放的
? ? ? ? 2.存在线程安全，如果在多线程下，两个或多个都走完if (_instance == nullptr)时候，交出cpu使用权，那么会倒是一个进程中有多个单例的实例
版本二
class Singleton
{
public:
static Singleton * GetInstance()
{
if (_instance == nullptr)
{
_instance = new Singleton();
atexit(Destructor);
}
return _instance;
}
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()指向的函数，而无需使用参数，该版本解决了资源释放的问题
版本三
#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(); // 1. 分配内存 // 2. 调用构造函数 // 3. 返回指针 // 多线程环境下 cpu reorder操作
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 Singleton()操作的时候，可能会出现cpu优化指令的情况，new分为三步1. 分配内存。??2. 调用构造函数。?3. 返回指针。??
cpu reorder操作的时候，可能会出现先执行1和3，在执行2，此时如果多线程模式下，如果线程A执行了1和3，此时交出cpu执行权，线程B拿到执行权，使用单例时候，发现内存已分配，会直接使用，但此时构造函数还没有执行，导致内存没有正确的初始化，会出现偶现bug
版本四
// volitile
#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这里利用的C++11的特性，来保证解决内存排序的问题
版本五
// 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&) {}
};
// 继承 Singleton
// g++ Singleton.cpp -o singleton -std=c++11
/*该版本具备 版本5 所有优点：
* 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&) {}
};版本六通过模板的方式，解决了版本五无法扩展的问题
