C++之单例模式

单利模式的优缺点和使用场景 

首先介绍一下单例模式： 
    单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。 

实现单例模式的思路是： 
    一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名 称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们 还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。 

需要注意的地方： 
    单例模式在多线程的 应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例， 这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。 

优点： 
    1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例 
    2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 
    3.提供了对唯一实例的受控访问。 
    4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 
    5.允许可变数目的实例。 
    6.避免对共享资源的多重占用。 
缺点： 
    1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 
    2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 
    3.单例类的职责过重，在一定程度上违背了“单一职责原则”。 
    4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。 
使用注意事项： 
    1.使用时不能用反射模式创建单例，否则会实例化一个新的对象 
    2.使用懒单例模式时注意线程安全问题 
    3.饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式模式） 
适用场景： 
    单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如： 
    1.需要频繁实例化然后销毁的对象。 
    2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。 
    3.有状态的工具类对象。 
    4.频繁访问数据库或文件的对象。 
以下都是单例模式的经典使用场景： 
    1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 
    2.控制资源的情况下，方便资源之间的互相通信。如线程池等。 
应用场景举例： 
    1.外部资源：每台计算机有若干个打印机，但只能有一个PrinterSpooler，以避免两个打印作业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件 
    2. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~ 
    3. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。 
    4. 网站的计数器，一般也是采用单例模式实现，否则难以同步。 
    5. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。 
    6. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。 
    7. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。 
    8. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。 
    9. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。 
    10. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例. 
　　 
实现单利模式的原则和过程： 
    1.单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例 
    2.单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式） 
    3.单例模式要素： 
        a.私有构造方法 
        b.私有静态引用指向自己实例 
        c.以自己实例为返回值的公有静态方法 

1.饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法） 

/**
* 饿汉式（推荐）
*
*/
public class Test {
        private Test() {
        }
        public static Test instance = new Test();
        public Test getInstance() {
                return instance;
        }
}

优点 
    1.线程安全 
    2.在类加载的同时已经创建好一个静态对象，调用时反应速度快 
缺点 
    资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化 


2.懒汉式：单例实例在第一次被使用时构建，延迟初始化。 

class Test {
        private Test() {
        }
        public static Test instance = null;
        public static Test getInstance() {
                if (instance == null) {
              //多个线程判断instance都为null时，在执行new操作时多线程会出现重复情况
                        instance = new Singleton2();
                }
                return instance;
        }
}

优点： 
    避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。 
缺点： 
    懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。 

3.双重检测 

class Test {
        private Test() {
        }
        public static Test instance = null;

        public static Test getInstance() {
                if (instance == null) {
                        synchronized (Test.class) {
                                if (instance == null) {
                                        instance = new Test();
                                }
                        }
                }
                return instance;
        }
}

优点 
    资源利用率高，不执行getInstance()就不被实例，可以执行该类其他静态方法 
缺点 
    第一次加载时反应不快，由于java内存模型一些原因偶尔失败 


4.静态内部类 

class Test {
        private Test() {
        }

        private static class SingletonHelp {
                static Test instance = new Test();
        }

        public static Test getInstance() {
                return SingletonHelp.instance;
        }
}

优点 
    资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法 
缺点 
    第一次加载时反应不够快 

总结： 
    一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测 。

单例模式

单例模式(Singleton Pattern)是设计模式最简单的形式之一，其目的是使得一个对象成为系统中的唯一实例。
这种设计模式及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，需要实例化该类的对象。

单例模式的三大要点：

• 单例类有且仅有一个实例
• 单例类必须自行创建自己的唯一实例
• 单例类必须给所有其他对象提供这一实例

实现角度分为三点：

• 提供一个private构造函数(防止外部调用而构造类的实例)
• 提供一个该类的static private对象
• 提供一个static public函数，用于创建获取其本身的静态私有对象(例如：GetInstance())

除此之外还有一些关键点

• 线程安全(双检锁-DCL，即：double-checked locking)
• 资源释放

局部静态变量

这种方式很常见，实现非常简单，而且无需担心单例的销毁问题。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
// 非真正意义上的单例
class Singleton
{
　　public: 
　　static Singleton& GetInstance() 
{
　　static Singleton instance;
　　return instance;
 }
private: 
　　Singleton(){}
};
#endif // SINGLETON_H

但是，这并非真正意义上的单例。当使用如下方式访问单例时：

Singleton single = Singleton::GetInstance();

这会出现了一个类拷贝问题，从而违背了单例的特性。产生这个问题原因在于：编译器会生成一个默认的拷贝构造函数，来支持类的拷贝。
为了避免这个问题，有两种解决方式：

1. 将 GetInstance() 函数的返回类型修改为指针，而非引用。
2. 显式地声明类的拷贝构造函数，并重载赋值运算符。

对于第一种方式，只需要修改 GetInstance() 的返回类型即可：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
// 单例
class Singleton
{
public: 
    // 修改返回类型为指针类型 
    static Singleton* GetInstance() 
    { 
       static Singleton instance; 
       return &instance; 
    }
private: 
    Singleton() {}
  };#endif // SINGLETON_H

既然编译器会生成一个默认的拷贝构造函数，那么，为什么不让编译器不这么干呢？这就产生了第二种方式：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>

using namespace std;
// 单例
class Singleton
{
public: 
     static Singleton& GetInstance() 
         { 
           static Singleton instance; 
           return instance; 
         } 
         void doSomething() 
         { 
             cout << "Do something" << endl; 
         }
private: 
         Singleton() {} // 构造函数（被保护） 
         Singleton(Singleton const &); // 无需实现
         Singleton& operator = (const Singleton &); // 无需实现};

#endif // SINGLETON_H

这样以来，既可以保证只存在一个实例，又不用考虑内存回收的问题。

Singleton::GetInstance().doSomething(); // OK
Singleton single = Singleton::GetInstance(); // Error 不能编译通过

懒汉式/饿汉式

在讲解之前，先看看 Singleton 的头文件（懒汉式/饿汉式公用）：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
// 单例 - 懒汉式/饿汉式公用
class Singleton
{
public:
     static Singleton* GetInstance();
private: 
     Singleton() {} // 构造函数（被保护）
private: 
     static Singleton *m_pSingleton; // 指向单例对象的指针
};
#endif // SINGLETON_H

懒汉式的特点：

• Lazy 初始化
• 非多线程安全

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁（在“线程安全”部分分享如何加锁）才能保证单例，但加锁会影响效率。

// singleton.cpp
#include "singleton.h"

// 单例 - 懒汉式
Singleton *Singleton::m_pSingleton = NULL;

Singleton *Singleton::GetInstance()
{
     if (m_pSingleton == NULL) 
         m_pSingleton = new Singleton();
     return m_pSingleton;
}

饿汉式的特点：

• 非 Lazy 初始化
• 多线程安全

优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。

// singleton.cpp
#include "singleton.h"

// 单例 - 饿汉式
Singleton *Singleton::m_pSingleton = new Singleton();

Singleton *Singleton::GetInstance()
{ 
    return m_pSingleton;
}

线程安全
在懒汉式下，如果使用多线程，会出现线程安全隐患。为了解决这个问题，我们引入了双检锁 - DCL 机制。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
#include <mutex>
using namespace std;

// 单例 - 懒汉式/饿汉式公用
class Singleton
{
public: 
static Singleton* GetInstance();
private: 
Singleton() {} // 构造函数（被保护）
private: 
    static Singleton *m_pSingleton; // 指向单例对象的指针
    static mutex m_mutex; // 锁
};

#endif // SINGLETON_H

// singleton.cpp
#include "singleton.h"

// 单例 - 懒汉式（双检锁 DCL 机制）
Singleton *Singleton::m_pSingleton = NULL;
mutex Singleton::m_mutex;

Singleton *Singleton::GetInstance()
{
     if (m_pSingleton == NULL) { 
         std::lock_guard<std::mutex> lock(m_mutex); // 自解锁 
         if (m_pSingleton == NULL) { 
             m_pSingleton = new Singleton(); 
         } 
      } 
      return m_pSingleton;
}

这样，就可以保证线程安全了，但是，会带来较小的性能影响。

资源释放

有内存申请，就要有对应的释放，可以采用下述两种方式：

• 主动释放（手动调用接口来释放资源）
• 自动释放（由程序自己释放）

要手动释放资源，添加一个 static 接口，编写需要释放资源的代码：

// 单例 - 主动释放
static void DestoryInstance()
{ 
　　if (m_pSingleton != NULL) 
　　{ 
　　　　delete m_pSingleton; 
　　　　m_pSingleton = NULL; 
　　}
}

然后在需要释放的时候，手动调用该接口：

Singleton::GetInstance()->DestoryInstance();

方式虽然简单，但很多时候，容易忘记调用 destoryInstance()。这时，可以采用更方便的方式：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>

using namespace std;

// 单例 - 自动释放
class Singleton
{
public:
    static Singleton* GetInstance();
private: 
    Singleton() {} // 构造函数（被保护）
private: 
     static Singleton *m_pSingleton; // 指向单例对象的指针 

     // GC 机制 
     class GC 
     { 
     public:
        ~GC() 
       { 
           // 可以在这里销毁所有的资源，例如：db 连接、文件句柄等
           if (m_pSingleton != NULL) { 
               cout << "Here destroy the m_pSingleton..." << endl;
               delete m_pSingleton; 
               m_pSingleton = NULL; 
             }
        } 
        static GC gc; // 用于释放单例
 };
};
#endif // SINGLETON_H

只需要声明 Singleton::GC 即可：

// main.cpp
#include "singleton.h"

Singleton::GC Singleton::GC::gc; // 重要

int main()
{ 
    Singleton *pSingleton1 = Singleton::GetInstance(); 
    Singleton *pSingleton2 = Singleton::GetInstance();

    cout << (pSingleton1 == pSingleton2) << endl;

 return 0;
}

在程序运行结束时，系统会调用 Singleton 的静态成员 GC 的析构函数，该析构函数会进行资源的释放。这种方式的最大优点就是在“不知不觉”中进行，所以，对我们来说，尤为省心。

单例模式总结

要求: 在内存中只能生成一个对象
> 1. 将构造函数私有化
> 2. 在类中顶一个静态指针，在类之外初始化为空
> 3. 在类中再顶一个返回值为类对象指针的静态成员函数

实例代码：

饿（懒）汉模式

（懒加载）

#include <stdio.h>
#include <iostream>
using std::cout;
using std::endl;

//单例模式Singleton
//
//要求：只能由该类创建一个对象
//1. 该对象不能是栈对象或全局对象
//2. 只能是堆对象
//3. 该对象只有一个

//功能：
//	替换全局变量

//应用场景:
//1. 词典类
//2. 配置文件


class Singleton
{//类内部可以调用私有成员
public:
	static Singleton * getInstance()
	{
		if(_pInstance == NULL)
		{
			_pInstance = new Singleton();
		}
		return _pInstance;
	}

	static void destroy()
	{
		if(_pInstance)
		{
			delete _pInstance;
		}
	}

private://1.将构造函数私有化
	Singleton(){	cout << "Singleton()" << endl;}
	~Singleton(){	cout << "~Singleton()" << endl;	}

private:
	static Singleton * _pInstance;
};

Singleton * Singleton::_pInstance = NULL;

//Singleton s3;
//static Singleton s4;
 
int main(void)
{
	//Singleton s1;//调用了无参构造函数, 不能让该语句编译通过
	//Singleton s2;
	
	//Singleton * pSingleton = new Singleton();//堆对象, 类之外
	Singleton * pSingleton1 = Singleton::getInstance();
	Singleton * pSingleton2 = Singleton::getInstance();
	
	printf("pSingleton1 = %p
", pSingleton1);
	printf("pSingleton2 = %p
", pSingleton2);

	//delete pSingleton1;//error
	
	Singleton::destroy();

	return 0;
}

　　

饱汉模式----自动释放

方案一：静态对象 + 嵌套类

///**********************************************
 /// @file    singleton.cc
 /// @author  alex(AlexCthon@qq.com)
 /// @date    2018-06-18 21:58:17
 ///**********************************************/
#include <stdio.h> 
#include <iostream>
using std::cout;
using std::endl;
//自动-->析构函数
//方案一：单例对象的自动释放
//	静态对象 + 嵌套类
//	跨平台的方案（平台无关性)
class Singleton
{
private:
    class Autorelease
    {
    public:
	Autorelease(){cout << "Autorelease()" <<endl;;}
	~Autorelease(){
	    if(_pInstance)
		delete _pInstance;
	    cout << "~Autorelease()" << endl;
	}
    };

public:
    static Singleton* getInstance()
    {//多线程环境下是非线程安全的
	//加锁
	if(_pInstance==NULL)
	    _pInstance = new Singleton();
	return _pInstance;
    }
private:
    Singleton(){cout<<"Singleton()"<<endl;}
    ~Singleton(){cout<<"~Singleton()"<<endl;}
private:
    static Singleton *_pInstance;
    static Autorelease _auto;
};
//Singleton*Singleton::_pInstance = NULL;//饿（懒）汉模式-->懒加载
//静态数据成员的初始化
Singleton*Singleton::_pInstance= getInstance();//饱汉模式
Singleton::Autorelease Singleton::_auto;

int main()
{
    Singleton *p1 = Singleton::getInstance();
    Singleton *p2 = Singleton::getInstance();
    printf("p1=%p
",p1);
    printf("p2=%p
",p2);
    return 0;
}

　　

方案二：atexit + pthread_once

 
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h> //POSIX
#include <iostream>
using std::cout;
using std::endl;

//
//方案二: 单例对象的自动释放
//	> atexit + pthread_once 

class Singleton
{
public:
	static Singleton * getInstance() 
	{	//pthread_once所注册的函数在多线程环境下只会被执行一次
		//线程安全的
		pthread_once(&_once, init);
		return _pInstance;
	}

	static void init()
	{
		_pInstance = new Singleton;
		atexit(destroy);
	}

	static void destroy()
	{
		if(_pInstance)
			delete _pInstance;
	}

private:
	Singleton() {	cout << "Singleton()" << endl;	}
	~Singleton(){	cout << "~Singleton()" << endl;}
	
private:
	static Singleton * _pInstance;
	static pthread_once_t _once;
};

//静态数据成员的初始化
Singleton * Singleton::_pInstance = NULL;//饿(懒)汉模式  --> 懒加载
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;


int main(void)
{
	Singleton * p1 = Singleton::getInstance();
	Singleton * p2 = Singleton::getInstance();
	//Singleton::getInstance()->print();

	printf("p1 = %p
", p1);
	printf("p2 = %p
", p2);
	
	return 0;
}

　　编译：g++  singleton1.cc -lpthread