设计模式---------单例模式

前言：

• 单例模式，顾名思义就是只有一个实例，并且其负责创建自己的对象。

• 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

• 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

---

---

实例演示。。。。

---

---

单例模式的几种实现方式:

1、懒汉式，线程不安全

是否 Lazy 初始化：是
是否多线程安全：否
实现难度：易
描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

代码：

class Singleton{
	public:
		static Singleton* GetInstance();    //指针
	private：
		Singleton(){};
		Singleton(const Singleton&){};//禁止拷贝
		Singleton& operator = (const Singleton&){};//禁止赋值
		
		static Singleton* instance;   //静态成员变量
};
//初始化
Singleton* Singleton::instance = NULL;
Singleton* Singleton::GetInstance(){
	if(instance == NULL){
		instance = new Singleton();     //懒汉式做法，用到才创建
	}
	return instance;
}

通俗一点，“懒汉式”就是在你真正用到的时候才去建这个单例对象，这也就是为什么不能用于多线程的原因。

注意：懒汉式，是可以做到线程安全的（双检锁）

2、饿汉式，线程安全

是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种方式比较常用，但容易产生垃圾对象。（就是不管你用不用，都会产生）
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

代码：

class Singleton{
	public:
		static Singleton* GetInstance();
	private:
	    Singleton(const Singleton&){};
        Singleton& operator=(const Singleton&){};
		Singleton(){};
		static Singleton* instance;
};

Singleton* Singleton::instance = new Singleton();    //先进行初始化，创建对象
Singleton* Singleton::GetInstance(){
	return instance;
}

饿汉式单例模式：在类加载时就完成了初始化，所以类加载比较慢、获取对象的速度快、以空间换取时间模式、线程安全。（换句话说，不管你用的用不上，一开始就建立这个单例对象）

3、双检锁/双重校验锁（DCL，即 double-checked locking）

是否 Lazy 初始化：是
是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

代码：

这个双检锁就可以解决懒汉式单例问题！

class Singleton  
{  
private:  
    static Singleton* m_instance;  
    Singleton(){}  
public:  
    static Singleton* getInstance();  
};  
  
Singleton* Singleton::getInstance()  
{  
    if(NULL == m_instance)  
    {  
        Lock();//借用其它类来实现，如boost  
        if(NULL == m_instance)  
        {  
            m_instance = new Singleton;  
        }  
        UnLock();  
    }  
    return m_instance;  
}  

这里有个疑惑，就是外面判断了m_instance实例是否存在，为什么还要在lock里面做一次判断？

原因：当m_instance为null并且同时有2个线程调用getInstance方法时候，他们都会通过第一重的m_instance== null 的判断。然后由于lock机制，就只有一个线程能进入，另外一个线程等待，如果没有第二个判断，那么是不是就多new了空间，而且不能释放，是不是就变成了垃圾代码。

C++11以后可以用：用内部静态变量改进的懒汉式（线程安全）

静态局部变量有以下特点：
（1）该变量在全局数据区分配内存；
（2）静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
（3）静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为 0；
（4）它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。

///  内部静态变量的懒汉实现  //
class Single
{

public:
    // 获取单实例对象
    static Single &GetInstance();
	
	// 打印实例地址
    void Print();

private:
    // 禁止外部构造
    Single();

    // 禁止外部析构
    ~Single();

    // 禁止外部复制构造
    Single(const Single &signal);

    // 禁止外部赋值操作
    const Single &operator=(const Single &signal);
};

Single &Single::GetInstance()
{
    // 局部静态特性的方式实现单实例
    static Single signal;
    return signal;
}

//或者
Single *Single::GetInstance()
{
    // 局部静态特性的方式实现单实例
    static Single signal;
    return &signal;
}

void Single::Print()
{
	std::cout << "我的实例内存地址是:" << this << std::endl;
}

Single::Single()
{
    std::cout << "构造函数" << std::endl;
}

Single::~Single()
{
    std::cout << "析构函数" << std::endl;
}
///  内部静态变量的懒汉实现  //

参考网页，请点击！
参考博客一，请点击！
参考博客二，请点击！