一、单例模式的动机
相信大家都使用过Windows任务管理器，我们可以做一个尝试：在Windows任务栏的右键菜单上多次点击“启动任务管理器”，看能否打开多个任务管理器窗口。正常情况下，无论我们启动多少次，Windows系统始终只能弹出一个任务管理器窗口。也就是说，在一个Windows系统中，任务管理器存在唯一性。
在实际开发中，我们经常也会遇到类似的情况，为了节约系统资源，有时候需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，可以通过创建单例模式来实现，这也就是单例模式的动机所在。
二、单例模式概述
2.1 要点
单例（Singleton）模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建模式。
单例模式有3个要点： 1. 某个类只能有一个实例 2. 它必须自行创建这个实例 3. 它必须自行向整个系统提供这个实例
2.2 结构图
从上图中可以看出，单例模式结构图中只包含了一个单例的角色。
Singleton（单例）：
在单例类的内部实现只生成一个实例，同时它提供一个静态的GetInstance()方法，让客户可以访问它的唯一实例；为了防止在外部对单例类实例化，它的构造函数被设为private；在单例类的内部定义了一个Singleton类型的静态对象，作为提供外部共享的唯一实例。三、单例模式案例 单例模式有许多种实现方法，
a.懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁) b.饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间
特点与选择：
1.如果要进行线程同步，访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。 2.在访问量较小时，采用懒汉实现。这是以时间换空间。
在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显得很不优雅。定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有静态方法获取该实例。如下面的类定义：
#include <iostream> class CSingleton { public: char count; static CSingleton *GetInstance() { if(NULL == m_pInstance) { m_pInstance = new CSingleton(); } return m_pInstance; } private: CSingleton(){}; static CSingleton *m_pInstance; }; CSingleton *CSingleton::m_pInstance = NULL; int main() { CSingleton *Obj = CSingleton::GetInstance(); if(NULL != Obj) { Obj->count = 12; printf("The count is:%d\n", Obj->count); } while(1); return 1; }C++单例模式类CSingleton有以下特征：
1、它有一个指向唯一实例的静态指针m_pInstance，并且是私有的。 2、它有一个公有的函数，可以获取这个唯一的实例，并在需要的时候创建该实例。 3、它的构造函数是私有的，这样就不能从别处创建该类的实例。
大多时候，这样的实现都不会出现问题，但是设计class应当像设计type一样，需要考虑初始化和销毁。再来看m_pInstance指向的空间什么时候释放呢？更严重的问题是，这个实例的析构操作什么时候执行？ 如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面所示的代码无法实现这个要求。我们需要一种方法，正常地删除该实例。
为什么不在析构函数中释放m_pInstance呢？
1、单例中的new的对象需要delete释放。 2、delete释放对象的时候才会调用对象的析构函数。 3、如果在析构函数里调用delete，那么程序结束时，根本进不去析构函数，怎么会delete。 4、如果程序结束能自动析构，那么就会造成一个析构的循坏，所以new对应于delete。
可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。
一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上，使其在恰当的时候自动被执行。
我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中Garbage类：
#include <iostream> //懒汉式 （创建的时候采取new实例）以时间换取空间，线程不安全 class CSingleton { public: char count; static CSingleton *GetInstance() { if(NULL == m_pInstance) { m_pInstance = new CSingleton(); } return m_pInstance; } private: CSingleton(){}; static CSingleton *m_pInstance; class Garbage// 它的唯一工作就是在析构函数中删除 CSingleton的实例 { public: ~Garbage() { if(CSingleton::m_pInstance) { delete CSingleton::m_pInstance; m_pInstance = NULL; printf("...........\n"); } } static Garbage garbage;// 定义一个静态成员，在程序结束时，系统会调用它的析构函数 }; }; CSingleton *CSingleton::m_pInstance = NULL; CSingleton::Garbage CSingleton::Garbage::garbage;//静态类对象类外声明 int main() { CSingleton *Obj = CSingleton::GetInstance(); if(NULL != Obj) { Obj->count = 12; printf("The count is:%d\n", Obj->count); } return 1; }类Garbage被定义为CSingleton的私有内嵌类，以防该类被在其它地方滥用。 在程序运行结束时，系统会调用CSingleton的静态成员Garbage的析构函数，该析构函数会删除单例的唯一实例。 使用这种方法释放C++单例模式对象有以下特征：
在单例类内部定义专有的嵌套类。 在单例类内定义私有的专门用于释放的静态成员。 利用程序在结束时析构全局变量的特性，选择最终的释放时机。 使用C++单例模式的代码不需要任何操作，不必关心对象的释放。
但这是一个完美的实现吗？不！该方法是线程不安全的，考虑两个线程同时首次调用GetInstance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误！为了保证线程安全，可以用锁。
#include<stdio.h> #include<unistd.h> #include<malloc.h> #include<stdlib.h> #include<pthread.h> //懒汉式 线程安全式（双检锁） /* 所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不 同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重 检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个 实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进 行判断所浪费的时间。 */ class CSingleton { public: char count; static CSingleton *GetInstance() { if(NULL == m_pInstance) { pthread_mutex_lock(&mutex); //加锁 if(NULL == m_pInstance) { m_pInstance = new CSingleton(); } pthread_mutex_unlock(&mutex); } return m_pInstance; } static pthread_mutex_t mutex; private: CSingleton() { pthread_mutex_init(&mutex, NULL); } static CSingleton *m_pInstance; class Garbage// 它的唯一工作就是在析构函数中删除 CSingleton的实例 { public: ~Garbage() { if(CSingleton::m_pInstance) { delete CSingleton::m_pInstance; m_pInstance = NULL; printf("...........\n"); } } static Garbage garbage;// 定义一个静态成员，在程序结束时，系统会调用它的析构函数 }; }; CSingleton *CSingleton::m_pInstance = NULL; pthread_mutex_t CSingleton::mutex; CSingleton::Garbage CSingleton::Garbage::garbage;//静态类对象类外声明 int main() { CSingleton *Obj = CSingleton::GetInstance(); if(NULL != Obj) { Obj->count = 12; printf("The count is:%d\n", Obj->count); } return 1; } 结果： youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ sudo g++ test.cpp -o test.linux youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ sudo ./test.linux The count is:12 ........... youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$再来看看饿汉的实现方式,即无论是否调用该类的实例，在程序开始时就会产生一个该类的实例，并在以后仅返回此实例。
由静态初始化实例保证其线程安全性，WHY？因为静态实例初始化在程序开始时进入主函数之前就由主线程以单线程方式完成了初始化，不必担心多线程问题。
故在性能需求较高时，应使用这种模式，避免频繁的锁争夺。
#include<iostream> #include<stdio.h> class CSingleton { public: char count; static CSingleton *GetInstance() { return m_pInstance; } private: CSingleton() { } static CSingleton *m_pInstance; class Garbage// 它的唯一工作就是在析构函数中删除 CSingleton的实例 { public: ~Garbage() { if(CSingleton::m_pInstance) { delete CSingleton::m_pInstance; m_pInstance = NULL; printf("...........\n"); } } static Garbage garbage;// 定义一个静态成员，在程序结束时，系统会调用它的析构函数 }; }; CSingleton *CSingleton::m_pInstance = new CSingleton(); CSingleton::Garbage CSingleton::Garbage::garbage;//静态类对象类外声明 int main() { CSingleton *Obj = CSingleton::GetInstance(); if(NULL != Obj) { Obj->count = 12; printf("The count is:%d\n", Obj->count); } return 1; } 结果： youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ sudo g++ test.cpp -o test.linux youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$ sudo ./test.linux The count is:12 ........... youjiaxing@fanjunshuang-OptiPlex-7020:~/wbg/mytest$