singleton
转自：我想有个长长的名字的博客，剑指offer 面试题2 Singleton模式 C++实现
题目：实现Singleton模式
以下内容是我在看《剑指offer》的面试题2时，遇到的问题，因为书中使用C#实现，所以想用C++重新实现一下，Test方法不够全，后续还要完善。C++实现过程主要参考：C++设计模式——单例模式。
代码中的注释一般是我的笔记，或一些发现。
PS: 感谢勤劳的慵懒君~~ @亦余心之所向兮
1 解法一：单线程解法
缺点：多线程情况下，每个线程可能创建出不同的Singleton实例
// 剑指offer 面试题2 实现Singleton模式
#include <iOStream>
using namespace std;
class Singleton
{
public:
static Singleton* getinstance()
{
// 在后面的Singleton实例初始化时，若后面是new Singleton()，则此处不必new；（废话）
// 若后面是赋值成NULL，则此处需要判断，需要时new
// 注意！然而这两种方式并不等价！后面的Singleton实例初始化时，new Singleton(),其实是线程安全的，因为static初始化是在主函数main()之前，那么后面的方法岂不是很麻烦。。。。这也是我测试的时候想到的
/*
if(m_pInstance == NULL)
{
m_pInstance = new Singleton();
}
*/
return m_pInstance;
}
static void destroyInstance()
{
if(m_pInstance != NULL)
{
delete m_pInstance;
m_pInstance = NULL;
} }
private:
Singleton(){}
static Singleton* m_pInstance;
};
// Singleton实例初始化
Singleton* Singleton::m_pInstance = new Singleton(); // 前面不能加static，会和类外全局static混淆
// 单线程获取多次实例
void Test1(){
// 预期结果：两个实例指针指向的地址相同
Singleton* singletonObj = Singleton::getInstance();
cout << singletonObj << endl;
Singleton* singletonObj2 = Singleton::getInstance();
cout << singletonObj2 << endl;
Singleton::destroyInstance();
}
int main(){
Test1();
return 0;
}2 解法二：多线程+加锁
解法1是最简单，也是最普遍的实现方式，也是现在网上各个博客中记述的实现方式，但是，这种实现方式，有很多问题，比如：没有考虑到多线程的问题，在多线程的情况下，就可能创建多个Singleton实例，以下版本是改善的版本。
注意：下面的代码涉及互斥锁以及多线程测试，使用了C++11的多线程库，std::thread,，std::mutex，请使用支持C++11多线程的编译器，并确认开启了C++11的编译选项，具体方法见：http://blog.csdn.net/huhaijing/article/details/51753085
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
using namespace std;
class Singleton
{
private:
static mutex m_mutex; // 互斥量
Singleton(){}
static Singleton* m_pInstance;
public:
static Singleton* getInstance(){
if(m_pInstance == NULL){
m_mutex.lock(); // 使用C++11中的多线程库
if(m_pInstance == NULL){ // 两次判断是否为NULL的双重检查
m_pInstance = new Singleton();
}
m_mutex.unlock();
}
return m_pInstance;
}
static void destroyInstance(){
if(m_pInstance != NULL){
delete m_pInstance;
m_pInstance = NULL;
}
}
};
Singleton* Singleton::m_pInstance = NULL; // 所以说直接new 多好啊，可以省去Lock/Unlock的时间
mutex Singleton::m_mutex;
void print_singleton_instance(){
Singleton *singletonObj = Singleton::getInstance();
cout << singletonObj << endl;
}
// 多个进程获得单例
void Test1(){
// 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
vector<thread> threads;
for(int i = 0; i < 10; ++i){
threads.push_back(thread(print_singleton_instance));
}
for(auto& thr : threads){
thr.join();
}
}
int main(){
Test1();
Singleton::destroyInstance();
return 0;
} 此处进行了两次m_pInstance == NULL的判断，是借鉴了java的单例模式实现时，使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。
3 解法三：const static 型实例
#include <iostream>
#include <thread>
#include <vector>
using namespace std;
class Singleton
{
private:
Singleton(){}
static const Singleton* m_pInstance;
public:
static Singleton* getInstance(){
return const_cast<Singleton *>(m_pInstance); // 去掉“const”特性
// 注意！若该函数的返回值改为const static型，则此处不必进行const_cast静态转换
// 所以该函数可以改为：
/*
const static Singleton* getInstance(){
return m_pInstance;
}
*/
}
static void destroyInstance(){
if(m_pInstance != NULL){
delete m_pInstance;
m_pInstance = NULL;
}
}
};
const Singleton* Singleton::m_pInstance = new Singleton(); // 利用const只能定义一次，不能再次修改的特性，static继续保持类内只有一个实例
void print_singleton_instance(){
Singleton *singletonObj = Singleton::getInstance();
cout << singletonObj << endl;
}
// 多个进程获得单例
void Test1(){
// 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
vector<thread> threads;
for(int i = 0; i < 10; ++i){
threads.push_back(thread(print_singleton_instance));
}
for(auto& thr : threads){
thr.join();
}
}
int main(){
Test1();
Singleton::destroyInstance();
return 0;
} 因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。由于上述三种实现，都要考虑到实例的销毁，关于实例的销毁，待会在分析。
4 解法四：在get函数中创建并返回static临时实例的引用
PS：该方法不能人为控制单例实例的销毁
#include <iostream>
#include <thread>
#include <vector>
using namespace std;
class Singleton
{
private:
Singleton(){}
public:
static Singleton* getInstance(){
static Singleton m_pInstance; // 注意，声明在该函数内
return &m_pInstance;
}
};
void print_singleton_instance(){
Singleton *singletonObj = Singleton::getInstance();
cout << singletonObj << endl;
}
// 多个进程获得单例
void Test1(){
// 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
vector<thread> threads;
for(int i = 0; i < 10; ++i){
threads.push_back(thread(print_singleton_instance));
}
for(auto& thr : threads){
thr.join();
}
}
// 单个进程获得多次实例
void Test2(){
// 预期结果，打印出相同的地址，之间换行符分隔
print_singleton_instance();
print_singleton_instance();
}
int main(){
cout << "Test1 begins: " << endl;
Test1();
cout << "Test2 begins: " << endl;
Test2();
return 0;
}以上就是四种主流的单例模式的实现方式。
5 解法五：最终方案，最简&显式控制实例销毁
在上述的四种方法中，除了第四种没有使用new操作符实例化对象以外，其余三种都使用了；
我们一般的编程观念是，new操作是需要和delete操作进行匹配的；是的，这种观念是正确的。在上述的实现中，是添加了一个destoryInstance的static函数，这也是最简单，最普通的处理方法了；但是，很多时候，我们是很容易忘记调用destoryInstance函数，就像你忘记了调用delete操作一样。由于怕忘记delete操作，所以就有了智能指针；那么，在单例模型中，没有“智能单例”，该怎么办？怎么办？
在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。
但是，有以下情况，是必须需要进行实例销毁的：
在代码实现部分的第四种方法能满足第二个条件，但是无法满足第一个条件。好了，接下来，就介绍一种方法，这种方法也是我从网上学习而来的，代码实现如下：
#include <iostream>
#include <thread>
#include <vector>
using namespace std;
class Singleton
{
private:
Singleton(){}
static Singleton* m_pInstance;
// **重点在这**
class GC // 类似Java的垃圾回收器
{
public:
~GC(){
// 可以在这里释放所有想要释放的资源，比如数据库连接，文件句柄……等等。
if(m_pInstance != NULL){
cout << "GC: will delete resource !" << endl;
delete m_pInstance;
m_pInstance = NULL;
}
};
};
// 内部类的实例
static GC gc;
public:
static Singleton* getInstance(){
return m_pInstance;
}
};
Singleton* Singleton::m_pInstance = new Singleton();
Singleton::GC Singleton::gc;
void print_instance(){
Singleton* obj1 = Singleton::getInstance();
cout << obj1 << endl;
}
// 多线程获取单例
void Test1(){
// 预期输出：相同的地址，中间可能缺失换行符，属于正常现象
vector<thread> threads;
for(int i = 0; i < 10; ++i){
threads.push_back(thread(print_instance));
}
for(auto& thr : threads){
thr.join();
}
}
// 单线程获取单例
void Test2(){
// 预期输出：相同的地址，换行符分隔
print_instance();
print_instance();
print_instance();
print_instance();
print_instance();
}
int main()
{
cout << "Test1 begins: " << endl;
cout << "预期输出：相同的地址，中间可以缺失换行（每次运行结果的排列格式通常不一样）。" << endl;
Test1();
cout << "Test2 begins: " << endl;
cout << "预期输出：相同的地址，每行一个。" << endl;
Test2();
return 0;
} 在程序运行结束时，系统会调用Singleton的静态成员GC的析构函数，该析构函数会进行资源的释放，而这种资源的释放方式是在程序员“不知道”的情况下进行的，而程序员不用特别的去关心，使用单例模式的代码时，不必关心资源的释放。
那么这种实现方式的原理是什么呢？由于程序在结束的时候，系统会自动析构所有的全局变量，系统也会析构所有类的静态成员变量，因为静态变量和全局变量在内存中，都是存储在静态存储区的，所有静态存储区的变量都会被释放。
由于此处使用了一个内部GC类，而该类的作用就是用来释放资源，而这种使用技巧在C++中是广泛存在的，参见《C++中的RAII机制》。
运行结果：
相关阅读
基本上有兴趣了解设计模式的都会知道工厂模式，因为各种模式相关的书籍以及博客什么的都是以工厂模式开头的，对于一时兴起或者三天热
看springmvc适配器模式---HandlerAdapter
适配器模式 就是你有一个类接口，但是这个接口不太符合你的预期，如果要用他就需要在他的源码上进行一些修改，这时你可以做一个适配器
1.定义 它定义了一种一对多的关系，让多个观察者对象同时监听某一个主题对象，这个主题对象的状态发生变化时就会通知所有的观察者对
桥接模式（Bridged） 桥接模式就是将主机网卡与虚拟机虚拟的网卡利用虚拟网桥进行通信。在桥接的作用下，类似于把物理主机虚拟为一个
在实际工作过程中，作为一个项目经理，在解决冲突的时候可以通过多种模式解决，项目经理在处理冲突中将担当非常重要的角色，如果冲突处理