c++单例模式 ---超详细

一.概述：
因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最
恰当的解决办法。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。单例模式有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。
《设计模式》一书中的实现有三个要素，定义一个单例类，要使用类的私有静态指针变量指向类的唯一实例（即在类中就生成一个对象），并用一个公有的静态方法获取该实例，并把构造函数定义为protected或private。

二.懒汉式实现单例模式：
懒汉式的特点是延迟加载，懒汉么，很懒，它只在要用到实例时才加载实例。

/****************************************
2     > File Name:lanhan.cpp
3     > Author:xiaoxiaohui
4     > mail:1924224891@qq.com
5     > Created Time:2016年05月07日 星期六 15时01分25秒
6 ****************************************/
7
8 #include<iostream>
9 using namespace std
10
11 class Singleton
12 {
13 private:
14     Singleton()
15     {}
16     static Singleton* _instace;   //静态的  私有的
17 public:
18     static Singleton* GetInstace()
19     {
20         if(_instance == NULL)
21         {
22             _instance = new Singleton();
23         }
24         return _instance;   //如果非空则new一个对象 后者返回原来的两个对象（所以保证了只有一个对象生成）
25     }
26
27 }
28

上面的这一实现存在内存泄露问题，因为没有释放_instance指针，下面为懒汉式的改进版：

8 #include<iostream>
9 using namespace std
10
11 class Singleton
12 {
13 private:
14     Singleton()
15     {}
16     static Singleton* _instance;   //静态的  私有的
17
18     class del
19     {
20     public:
21         ~del()
22         {
23             if(Singleton::_instance != NULL)
24             {
25                 delete Singleton::_instance;
26                 Singleton::_instance = NULL;
27             }
28         }
29     }
30     static del d;  //静态变量会在程序结束时调用它的析构函数
31 public:
32     static Singleton* GetInstance()
33     {
34         if(_instance == NULL)
35         {
36             _instance = new Singleton();
37         }
38         return _instance;   //如果非空则new一个对象 后者返回原来的两个对象（所以保证了只有一个对象生成）
39     }
40
41 }

该实现会在程序结束时调用静态变量的析构函数，从而delete了唯一的Singleton对象。
使用这种方法释放单例对象有以下特征：
1.在单例类内部定义专有的嵌套类。
2.在单例类内定义私有的专门用于释放的静态成员。
3.利用程序在结束时析构全局变量的特性，选择最终的释放时机。

但是现在还有问题，如果在多线程环境下，因为“if(_instance == NULL)”并不是原子的，会存在线程安全问题（如果一个线程刚刚判断了指针为空，这时另一个线程的优先级更高或者其它原因，打断了原来线程的执行，再次判断指针也会为空，所以会出现两个实例）下面为多线程环境下的懒汉式单例模式：

8 #include<iostream>
9 #include<stdlib.h>
10 #include<pthread.h>
11
12 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
13 using namespace std
14
15 class Singleton
16 {
17 private:
18     Singleton()
19     {}
20     static Singleton* _instance;   //静态的  私有的
21
22     class del
23     {
24     public:
25         ~del()
26         {
27             if(Singleton::_instance != NULL)
28             {
29                 delete Singleton::_instance;
30                 Singleton::_instance = NULL;
31             }
32         }
33     }
34     static del d;  //静态变量会在程序结束时调用它的析构函数
35 public:
36     static Singleton* GetInstance()
37     {
38         pthread_mutex_lock(&lock);
39         if(_instance == NULL)
40         {
41             _instance = new Singleton();
42         }
43         pthread_mutex_unlock(&lock);
44         return _instance;   //如果非空则new一个对象 后者返回原来的两个对象（所以保证了只有一个对象生成）
45     }
46
47 }
48

但现在还有问题，当有大量的线程时，只会有一个线程进入互斥锁，然后执行下面的代码而其它线程只能等待，并且加锁是一个繁重的过程，这样会导致加很多次锁，这样就太不高效了。下面是高效版的多线程环境下的懒汉式单例模式：

8 #include<iostream>
9 #include<stdlib.h>
10 #include<pthread.h>
11
12 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
13 using namespace std
14
15 class Singleton
16 {
17 private:
18     Singleton()
19     {}
20     static Singleton* _instance;   //静态的  私有的
21
22     class del
23     {
24     public:
25         ~del()
26         {
27             if(Singleton::_instance != NULL)
28             {
29                 delete Singleton::_instance;
30                 Singleton::_instance = NULL;
31             }
32         }
33     }
34     static del d;  //静态变量会在程序结束时调用它的析构函数
35 public:
36     static Singleton* GetInstance()
37     {
38         if(_instance == NULL)
39         {
40              pthread_mutex_lock(&lock);
41              if(_instance == NULL)
42              {
43                 _instance = new Singleton();
44              }
45              pthread_mutex_unlock(&lock);
46         }
47         return _instance;   //如果非空则new一个对象 后者返回原来的两个对象（所以保证了只有一个对象生成）
48     }
49
50 }

这样只有没有Singleton实例时才会进入加锁的代码，而当有Singleton实例时不需要进入加锁的代码中，直接返回已存在的实例就行了。

三.饿汉式的单例模式：在一开始就创建实例，要用时直接返回即可。饿汗式的单例模式没有线程安全问题，因为所以线程都只能访问一个已存在的对象，无论线程怎么调度都不会有多个对象出现。因为对象是一个静态变量（不是指针），会在程序结束时自动调用它的析构函数，所以不用考虑内存泄露问题。
饿汗式的特点：代码简单，不会出现内存泄露，是线程安全的。

1 /****************************************
2     > File Name:erhan.cpp
3     > Author:xiaoxiaohui
4     > mail:1924224891@qq.com
5     > Created Time:2016年05月07日 星期六 16时10分56秒
6 ****************************************/
7
8 #include<iostream>
9 using namespace std
10
11
12 class Singleton
13 {
14 private:
15     Singleton()
16     {}
17     static Singleton instance ;    //静态变量只会有一份数据存在 从而保证只有一个实例
18 public:
19     static Singleton& GetInstance()
20     {
21         return instance;
22     }
23 }

声明一个局部的静态变量，而静态变量在全局范围内只有一份数据，所以无论调用多少此GetInstance，返回的都是那一个实例。
但这个实现存在问题，Singleton singleton = Singleton :: GetInstance()，这么做就出现了一个类拷贝的问题，这就违背了单例的特性。产生这个问题原因在于：因为在这里没有实现拷贝构造函数，编译器会为类生成一个默认的拷贝构造函数，来支持类的拷贝。
解决方法：1.自己再定义一个拷贝构造函数和operator=，这个拷贝构造函数和operator=什么都不做。
2.返回一个Singleton指针。
下面为方法2的代码：

8 #include<iostream>
9 using namespace std
10
11
12 class Singleton
13 {
14 private:
15     Singleton()
16     {}
17     static Singleton instance ;    //静态变量只会有一份数据存在 从而保证只有一个实例
18 public:
19     static Singleton* GetInstance()
20     {
21         return &instance;
22     }
23 }

总结：单例模式适用于只允许一个实例存在的情况，它的实现必须满足三个条件，一是必须在类中就定义一个实例；二是必须有一个公有的静态方法来获取该实例；三是构造函数必须是私有的，来保证不容许别人通过调用构造函数来生成一个实例。在实现时要注意内存泄露问题，线程安全问题，性能问题。