保证一个类中仅有一个实例,并且提供一个访问他的全局访问点
a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁)
b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间
#注意
1. 构造函数私有化，
2. 私有的静态类指针指向类的实例（类外声明）
3. 共有的静态方法去获取一个访问实例的访问点
4. 析构函数需要定义一个嵌套类的析构函数去释放单例
5. 绝对不要在单例的析构函数中释放单例(coredump)!!!!!!!!! 详情看下面有问题的单例代码
singleton_L(){}
static singleton_L* instance; //单例唯一实力
static Garbo garbo; //静态私有的嵌套类对象,防止被外界访问
singleton_L* singleton_L::instance = NULL;
singleton_L::Garbo singleton_L::garbo; //静态类对象类外声
B懒汉式 ，线程安全方法
//懒汉式 线程安全式（双检锁）
所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不
同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重
检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个
实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进
行判断所浪费的时间。
class singleton_L_Lock
public:
static singleton_L_Lock* getinstance()
if(instance == NULL)
pthread_mutex_lock(&mutex); //加锁
if(instance == NULL)
instance = new singleton_L_Lock();
pthread_mutex_unlock(&mutex);
return instance;
private:
class GGGarbo
public:
~GGGarbo()
if(singleton_L_Lock::instance != NULL)
delete singleton_L_Lock::instance;
singleton_L_Lock::instance = NULL;
public:
static pthread_mutex_t mutex;
private:
singleton_L_Lock()
pthread_mutex_init(&mutex, NULL);
private:
static singleton_L_Lock* instance;
static GGGarbo gggarbo;
singleton_L_Lock* singleton_L_Lock::instance = NULL;
pthread_mutex_t singleton_L_Lock::mutex;
singleton_L_Lock::GGGarbo singleton_L_Lock::gggarbo;
c.饿汉式
，不牵扯线程安不安全，以空间换时间
//饿汉式（在定义实例的时候就去new对象）以空间换时间
class singleton_E
public:
static singleton_E* getinstance()
return instance;
// ~singleton_E(){}
class GGarbo
public:
~GGarbo()
if(singleton_E::instance != NULL)
cout << "delete singleton_E" << endl;
delete singleton_E::instance;
singleton_E::instance = NULL;
private:
singleton_E(){}
static singleton_E* instance;
static GGarbo ggarbo;
singleton_E* singleton_E::instance = new singleton_E();
singleton_E::GGarbo singleton_E::ggarbo;
以上就是我对单例模式的一些理解心得，如有不对的地方多多指教，哈哈哈。
这是在网上找的方法，在这里进行总结第一种方法：定义私有内嵌类：垃圾回收程序在结束的时候，系统会自动析构所有的全局变量，系统也会析构掉所有的类的静态成员变量，所以可以在单例类中定义一个这样的静态成员变量，它唯一的工作就是在析构函数中删除单例类的实例 CGarbo被定义为Csingleton的私有内嵌类，防止该类被在其他地方滥用 程序运行结束，系统调用CSingleton的静态成员Garbo的析构函数...
2.法一， 对象是new出来的。c++ 自己new出来的对象，需要自己释放。1. 法二，利用栈上内存，离开作用域会执行析构函数。对于， 要执行析构函数的单例类，要用第二种写法。单例的写法有一下两种。
设计模式思想是可重用，我们在编程的过程中，或多或少都会接触到设计模式，只是，有时，我们相交却未相识罢了，那么我们来讲解单例模式，并且附之一个C++的编程技巧。
我们知道单例模式在实际开发过程中是很有用的，单例模式的特征我们可能都知道：
1、一个类只有一个实例
2、提供一个全局访问点
3、禁止拷贝
我们来逐个分析：
1、如果要实现只有一个实例，我们需要做的事情：
a、将构造函数声明为私有
2、提供一个全局访问点
a、类中创建静态成员函数
3、禁止拷贝
a、拷贝构造函数声明为私有，并且不提供实现
b、将赋值运算符声明为私有
1、析构函数名是在类名前加以符号“~”。
2、析构函数没有参数、返回类型和修饰符。
3、一个类中至多有一个析构函数，如果程序员没有定义析构函数，那么系统会自动地加入一个析构函数。
4、不能显式地调用析构函数，而是由系统自动调用。
定义析构函数格式为：
~类名()
由于c#得到自动内存管理的支持，当对象生命期结束后，系统能够自动回收那些对象应该释放的资源等，所以一般不需要程序员的关心，对于一般的对象，程序中不需要定义析构函数。
阿会楠：《Visual c#.net程序设计教程》笔记
只有一个的windows任务管理器；
只有一个的windows回收站。。。
单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用。
几种单例模式实现
了解其本质就好。
以C++11为例
C++11提供的call_once和once_flag解决了单例类线程安全问题。
CData
有一个指唯一实例的静态指针m_pInstance，并且是私有的。
有一个公有的函数，可以获取这个唯一的实例，并在需要的时候创建该实例。
构造函数/拷贝构造是私有的，这样就不能从别处创建该类的实例。
m_pInstance指向的空间什么时候释放呢？
这个实例的析构操作什么时候执行？
网络上提供的解决方案如下：
链接1：https://www.cnblogs.com/wxxweb/archive/2011/04/15/2017088.html
链接2：https://bl
最近写完项目，正是一波总结的时候。项目中用到了大量的单例模式，然而本以为写的轻车熟路的代码，结果却问题重重，单例模式如何析构？单例模式中如何保证线程安全？如何加锁？锁要封装成单例类嘛？这个单例类构造出1个对象会不会有问题？阻塞住会不会后面上锁的功能无法正常使用？还是锁不用单例模式封装？构造锁的对象时加static？？......
不测试不知道，一测试一堆问题需要解决，好，从头开始看。
----...
单例模式定义
该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
在C++中，我个人的理解是，不需要自己new类指针，这样一方面也方便程序员自己管理内存，另一方面可以节省系统指针，减少占用内存资源。
单例模式的实现要求
简单的来说，就是一个类要有唯一的单例，而且这个单例类能够被其他对象所调用，不能用，那就没意义了嘛 。...
对系统中的某些类来说，只有一个实例很重要，例如我们常见的任务管理器，大家可以试试看能不能打开两个任务管理器，又比如Spring中的bean有singleton模式。单例模式是目的为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，我们无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。
单例模式的要点有三个：
是某个类只能有一个实例；
是它...
