一、什么是单例模式
1. 设计模式
模式就是解决问题的固定套路，设计模式(Design pattern)就是一套经过前人反复使用，总结出来的程序设计经验。设计模式总共分为三大类：
第一类是创建型模式 ，该模式通常和对象的创建有关，涉及到对象实例化的方式。包括：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式五种；
第二类是结构型模式，结构型模式描述的是如何组合类和对象来获得更大的结构。包括：代理模式、装饰者模式、适配器模式、桥接模式、组合模式、外观模式、享元模式共7种模式。
第三种是行为型模式，用来描述对类或对象怎样交互和怎样分配职责。共有：模板模式、命令模式、责任链模式、策略模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式、解释器模式、迭代器模式11种模式。
2. 单例模式
单例模式是创建型模式的一种，正常情况下，我们定义一个类是可以创建很多个对象的，而单例模式顾名思义就是指一个类只能创建一个实例对象，也就是说在整个程序空间中，这个类只有一个对象，并且对外提供一个全局访问点来访问这个唯一的实例对象。单例模式主要分为两类：
饿汉式单例模式：一开始就创建好了一个唯一的对象；
懒汉式单例模式：在使用实例对象的时候去创建该唯一的对象；
单例模式的结构图：
二、单例模式的实现
1. 懒汉式单例模式
1.1 如何保证只有一个实例对象
当我们在使用类来new创建一个对象的时候，会自动调用构造函数，每创建一个对象都会调用构造函数来构造一个新的对象
1. class classA{}; 2. 3. void func() 4. { 5. classA* a1 = new classA; //调用构造函数 6. classA* a2 = new classA; //调用构造函数 7. if (a1 != a2) 8. { 9. cout << "a1和a2是两个不同的对象" << endl; 10. } 11. }
在上面程序中，我们new了两个对象，会调用两次构造函数，并创建出两个不同的对象，我们可以直接通过判断来测试一下
既然我们希望这个类只有一个实例对象，那么就应该禁止类的外部访问构造函数，因为每次在类的外部调用构造函数都会构造出一个新的实例对象。解决办法就是把构造函数设置为私有属性，在类的内部完成实例化对象的创建，这样就对外隐藏了创建对象的方法。但是类的出现就是要定义对象的，我们要使用类创建的对象，所以还需要提供一个全局访问点来获取类内部创建好的对象
1. class SingletonPattern 2. { 3. private: 4. SingletonPattern() 5. { 6. cout << "私有的构造函数" << endl; 7. } 8. public: //构造函数被私有化了，所以应该提供一个对外访问的方法，来创建对象 9. static SingletonPattern* get_single() 10. { 11. if (single == NULL) //为保证单例，只new一次 12. { //如果不加这个判断，每次创建对象都会new一个single，这就不是单例了 13. single = new SingletonPattern; 14. } 15. //return this->single; 16. return single; //静态成员属于整个类，没有this指针 17. } 18. private: //static 成员，类定义的所有对象共有static成员 19. static SingletonPattern* single; //指针，不能是变量，否则编译器不知道如何分配内存 20. }; 21. 22. SingletonPattern* SingletonPattern::single = NULL; //告诉编译器分配内存
上面程序所示的就是一个懒汉式单例模式的实现。这里面有几点要注意的：
（1）为了让这个类所定义的所有对象共享属性，应该把属性设置为static类型，因为static类型的属性属于整个类而不是属于某个对象。
（2）为了保证单例模式，应该在全局访问点get_single()函数中加一个判断，如果对象已经被创建了，那么就直接返回这个对象，如果对象还没有被创建，那么久new创建一个对象，并返回该对象。
（3）因为是在使用到对象的时候，才去创建对象（single初始化为NULL，在全局访问点get_single被调用的时候才去创建对象），有点偷懒的感觉，所以称之为懒汉式单例模式。
我们再来测试一下，是不是真正的实现了单例
1. { 2. SingletonPattern* s1 = SingletonPattern::get_single(); //在get_single中会new一个对象 3. SingletonPattern* s2 = SingletonPattern::get_single(); 4. if (s1 == s2) 5. { 6. cout << "单例" << endl; 7. } 8. else 9. { 10. cout << "不是单例" << endl; 11. } 12. }
运行测试程序，看打印结果
通过打印结果可以看到，创建的两个对象s1和s2是相等的，也就是说我们实现了单例，通过全局访问点获取的实例对象是同一个。
通过上面的分析，我们可以得到实现单例模式的步骤
1. 构造函数私有化；
2. 提供全局访问点；
3. 内部定义一个static静态指针指向当前类定义的对象；
1.2 懒汉式单例模式的缺陷
通过懒汉式单例模式，我们实现了一个类只创建一个实例对象，且只有在用到实例对象的时候，才会通过全局访问点去new创建这个对象，节省了资源。但是，懒汉式单例模式有一个致命的缺点，就是在C++的构造函数中，不能保证线程安全。什么意思呢，也就是说，在多个线程都去创建对象，调用全局访问点get_single()的时候，会面临资源竞争问题，假如在类的构造函数中增加一个延迟函数，我们第一个线程调用get_single()的时候，会进入构造函数，这时，因为延时的存在，第一个线程可能会在这里卡顿一会，假如正好这时候第二个线程也调用get_single()去创建实例对象，而第一个线程还在构造函数中延时，这样在get_single()函数中(single == NULL)这个判断条件依然成立，第二个线程也会进入构造函数。这样，两个线程创建的对象就不再是同一个对象了，也就不是单例模式了。下面，我们就详细分析多线程与懒汉式。
2. 懒汉式单例模式与多线程
2.1 多线程构造对象
首先，我们把类改造一下，在构造函数中加一个延时，并在类中加一个计数器来记录构造函数的调用次数
1. class SingletonPattern 2. { 3. private: 4. SingletonPattern() 5. { 6. count++; 7. Sleep(1000); //第一个线程在new的时候，如果延时还没结束 8. //第二个线程又过来new一个对象，这时候因为第一个对象还没有new出来 9. //所以single还是NULL，这样又会进入构造函数，最后总共new了两个对象 10. //这样返回的两个对象是两次new出来的，就不是单例模式了 11. printf("私有的构造函数\n"); 12. } 13. public: 14. static int get_count() 15. { 16. return count; 17. } 18. public: //构造函数被私有化了，所以应该提供一个对外访问的方法，来创建对象 19. static SingletonPattern* get_single() //只有在调用该函数的时候才会new一个对象 20. { 21. if (single == NULL) 22. { 23. single = new SingletonPattern; 24. } 25. return single; 26. } 27. private: //static 成员，类定义的所有对象共有static成员 28. static SingletonPattern* single; 29. static int count; 30. }; 31. 32. SingletonPattern* SingletonPattern::single = NULL; 33. int SingletonPattern::count = 0;
这样，一个类就定义好了。接下来，我们要在main进程中创建三个线程，每个线程都去创建一个对象，在Windows下多线程编程应包含头文件<process.h>，并且会用到线程创建函数_beginthread()，对于_beginthread()函数的使用可以直接转到源码查看函数原型
1. typedef void (__cdecl* _beginthread_proc_type )(void*); 2. typedef unsigned (__stdcall* _beginthreadex_proc_type)(void*); 3. 4. _ACRTIMP uintptr_t __cdecl _beginthread( 5. _In_ _beginthread_proc_type _StartAddress, 6. _In_ unsigned _StackSize, 7. _In_opt_ void* _ArgList 8. );
该函数包含三个参数，分别代表如下含义：
第一个参数是_beginthread_proc_type，通过上面的typedef可知，它是一个回调函数（函数指针），指向新开辟的线程的起始地址；
第二个参数_StackSize是新线程的堆栈大小，可以直接给个0，表示和主线程共用堆栈；
第三个参数_ArgList是一个参数列表，它表示要传递给新开辟线程的参数，新线程没有参数的话可以传入NULL；
函数返回值可以理解为创建好的线程的句柄。
首先搭建测试程序如下
1. { 2. int i = 0, ThreadNum = 3; 3. HANDLE h_thread[3]; 4. 5. for (i = 0; i < ThreadNum; i++) 6. { 7. h_thread[i] = (HANDLE)_beginthread(_cbThreadFunc, 0, NULL); 8. } 9. 10. for (i = 0; i < ThreadNum; i++) 11. { 12. WaitForSingleObject(h_thread[i], INFINITE); //windows 下的等待 13. //thread_join //Linux 下的等待函数 14. //等待子线程结束，如果不等待子线程结束主进程就死掉的话，子线程也会随之死掉，所以主进程挂起等待 15. } 16. 17. cout << "子线程已结束" << endl; 18. }
这里用到了一个函数WaitForSingleObject()，它用于等待子线程结束。因为子线程是依附于主线程存在的（共用堆栈、内存四区），如果子线程还没结束主线程就结束了，那么子线程也将不复存在，所以需要等待子线程结束后，主线程才能结束。该函数类似于Linux中的thread_join函数。
搭建好测试程序后，在定义一个线程函数
1. void _cbThreadFunc(void* arc) 2. { 3. DWORD id = GetCurrentThreadId(); //获取当前线程ID 4. 5. int num = SingletonPattern::get_single()->get_count(); //创建对象 6. 7. printf("\n构造函数调用次数：%d\n", num); //调用了3次构造函数 --- 不是单例 8. printf("当前线程是：%d\n", id); 9. //cout << "当前线程是：" << id << endl; //会有问题 10. }
编译运行测试函数
可以看到，构造函数调用了三次，每个线程都创建了一个新的对象，已经不再是单例模式了。对于这个问题的解决主要有两种，下面分别介绍。
2.2 饿汉式单例模式
第一种解决方法就是在类中定义static SingletonPattern*指针的时候就创建一个对象，在全局访问点get_single()直接返回创建好的对象，因为对象早就提前创建好了，这样即使多个线程调用创建对象所得到的也是同一个对象。因为对象还没使用就创建好了，所以叫做饿汉式单例模式。
上面的测试程序不用修改，我们只需要修改类即可
1. class SingletonPattern 2. { 3. private: 4. SingletonPattern() 5. { 6. count++; 7. Sleep(1000); 8. printf("私有的构造函数\n"); 9. } 10. public: 11. static int get_count() 12. { 13. return count; 14. } 15. public: 16. static SingletonPattern* get_single() 17. { 18. return single; 19. } 20. private: 21. static SingletonPattern* single; 22. static int count; 23. }; 24. 25. //SingletonPattern* SingletonPattern::single = NULL; 26. SingletonPattern* SingletonPattern::single = new SingletonPattern; //饿汉式单例，一开始就new了一个对象 27. int SingletonPattern::count = 0;
再次运行前面的测试函数，看打印结果
从打印结果可以看到，三个不同的线程只调用了一次类的构造函数，得到的是同一个对象。
2.3 DCL(double-checked locking)
既然多个线程会竞争资源，那么如何才能防止多个线程之间的竞争呢？最简单的方法就是对临界区资源加一个锁🔒，当一个线程持有锁的时候，其他线程挂起等待锁的释放，只有持有锁的线程才能进入临界资源，这就解决了多线程资源竞争的问题（此处涉及到多线程同步问题）。这里还有一个问题，当我们第一次判断(single == NULL)后，如果之前没有创建对象，那么就进入下面的临界区
1. if (single == NULL) 2. { 3. cs.Lock(); 4. single = new SingletonPattern; 5. cs.Unlock(); 6. }
当第一个线程创建完对象后释放了锁，第二个线程进入临界区又创建了一个对象，这也违反了单例原则。所以应该加入一个二次检查，如果第一个线程已经创建了对象（指针不为NULL），那么第二个线程即使获取了锁，也不再创建新的对象，而是直接使用第一个线程创建的对象，这就是二次检测的原因。
1. static SingletonPattern* get_single() 2. { 3. if (single == NULL) //double check 4. { //因为在这之前并没有保护机制，所以三个线程都有可能执行到这一步 5. cs.Lock(); 6. if (single == NULL) //所以需要二次检查，进入临界区后再一次判断 7. { 8. single = new SingletonPattern; 9. } 10. cs.Unlock(); 11. } 12. return single; //静态成员属于整个类，没有this指针 13. }
对全局访问点get_single()修改过后，再次运行测试函数
三、总结
单例模式主要有懒汉式和饿汉式两种实现，饿汉式不会有线程安全的问题，但是提前构造对象占用了一定的资源，如果对内存要求较低的场景可以使用饿汉式实现；懒汉式应使用DCL机制来避免多线程竞争资源的问题，并且懒汉式可以在需要使用对象的时候才去创建对象，节省了资源。
