c++设计模式之单例模式

介绍

一个类无论创建多少对象，都只能得到一个实例

A* p1=new A();
A* p2=new A();
A* p3=new A();

如上述代码中，我们通过new运算符创建出了类A的三个对象实例，而我们现在要做的是，如何设计类A，使得上述代码运行之后永远只产生同一个对象实例

设计方法

1.将构造函数声明为私有

        我们知道，一个类对象是通过这个类的构造函数创建的，因此，我们首先要拒绝用户使用构造函数。

也许有人会问，我们在类中不写构造函数不行么？

确实不行，构造函数与普通成员函数的区别之一就在于，即使你不写，编译器也会自动为你创建一个构造函数

因此，这一步的目的在于：拒绝编译和用户使用构造函数创建对象

class Singleton
{
public:
private:
	Singleton(){};
};

2.在类中自行定义一个static对象

由于我们拒绝用户和编译器自行创建对象，因此我们必须自己在类中定义一个对象，且其类型必须为static的，因为只有static类型的变量才属于这个类，而不是属于某个对象

class Singleton
{
public:
private:
	static Singleton instance;
	Singleton(){};
};

声明为private的原因是，防止用户对其进行修改。

3.定义一个外部可以访问到该static对象实例的接口

由于上述定义的实例对象是private的，因此我们需要定义一个公共接口，来供外部用户进行访问

class Singleton
{
public:
	static Singleton& getInstance()
	{
		return instance;
	}
private:
	static Singleton instance;
	Singleton(){};
};

该接口声明为static的原因是，用户此时还没有创建出实例，而普通成员函数的调用必须通过对象进行，因此如果想要用户使用这个函数，就必须要将其声明为static的

4.拒绝对象的拷贝和赋值

至此，我们已经完成了一个半成品，也就是说，这个时候我们要使用Sington对象，就必须通过其中的static成员函数getInstance来获取，而该函数返回的对象实例永远都是同一个实例

#include<iostream>
using namespace std;

class Singleton
{
public:
	static Singleton& getInstance()
	{
		return instance;
	}
private:
	static Singleton instance;
	Singleton(){};
};

void test()
{
	/*
		此时，s1,s2,s3所指向的对象实例都是类中自己创建的那个instance
	*/
	Singleton* s1=Singleton::getInstance();
	Singleton* s2=Singleton::getInstance();
	Singleton* s3=Singleton::getInstance();
}

int main()
{
	test();
	return 0;
}

但还有个问题是，编译器还会为我们创建拷贝构造函数和拷贝赋值运算符，因此，当我们进行对象拷贝操作的时候，这个实例对象就不是“单例”的了

Singleton t=*p1;//此时编译器会自行创造出一个拷贝构造函数，从而创建出一个p1的副本

而解决这个问题的办法，上述也说明过，只需将其声明为私有即可

class Singleton
{
public:
	static Singleton& getInstance()
	{
		return instance;
	}
private:
	static Singleton instance;
	Singleton(){};

	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};

饿汉式单例模式

还没有获取对象实例，对象实例就已经创建了

上述最后的代码就是饿汉式单例模式，由于对象实例在类A是static的，因此我们在还没有调用接口在获取该对象的时候，它就已经存在了

class Singleton
{
public:
	static Singleton& getInstance()
	{
		return instance;
	}
private:
	static Singleton instance;
	Singleton(){};

	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};

因此，它的特点是

• 优点
  • 实现简单，线程安全：在类加载时就创建了实例，不存在多线程并发访问的问题
  • 执行效率高：没有加锁、同步等额外操作
• 缺点
  • 内存浪费：类加载时即创建实例，如果单例对象占用大量资源或者初始化耗时较长，会导致程序启动变慢。
  • 无法延迟加载：即使没有使用到该单例对象，也会被创建

懒汉式单例模式

唯一的实例，只有在第一次获取它的时候才会创建

由于饿汉式单例模式的缺陷，有了懒汉式单例模式的出现，也就是对象延迟加载，看代码

class Singleton
{
public:
	static Singleton* getInstance()
	{
		// return &instance;
		if(instance==nullptr)
		{
			instance=new Singleton();
		}
		return instance;
	}
private:
	static Singleton *instance;
	Singleton(){};

	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};
Singleton* Singleton::instance=nullptr;

最大的区别在于

我们将类中创建的对象实例声明为指针类型，这样当类加载的时候，内存中存在的是一个指针，而指针变量的大小永远都是固定的

	static Singleton *instance;

其次，再看接口函数的实现

	static Singleton* getInstance()
	{
		// return &instance;
		if(instance==nullptr)
		{
			instance=new Singleton();
		}
		return instance;
	}

该函数在调用时，首先会判断instance是否为nullptr，而instance为nullptr说明用户是第一次在代码中创建该实例，此时就new一个实例对象，返回给用户，而后续用户再创建实例对象时，instance就不为空了，直接返回即可

懒汉式单例模式的线程安全问题

在上述懒汉式单例模式的代码里，虽然可以实现对象的延迟加载，但是会存在多线程并发时代码的线程安全问题

考虑一种情况，假如现在有两个线程，都要执行如下代码创建单例对象的实例

Singleton* ptr1=Singleton::getInstance();

那么当线程1执行到这段代码时，开始执行下面这句代码时，突然切换回了线程2，而由于此时对象还没有被创建，因此线程2也能执行到这段代码

if(!instance)

那么问题来了，也就是说，此时线程1和线程2都执行到了上述这段代码，那么接下来，线程1和线程2就都可以创建这个“单例对象”

因此，在这种情况下，下述对象的号创建其实是被执行了两次

instance=new Singleton();

那么，如何避免这种情况的发生呢？

方法1

第一种方法很自然的就会想到使用互斥量锁住这段创建对象的代码，如下所示

class Singleton
{
public:
	static Singleton* getInstance()
	{
		std::lock_guard<std::mutex> lock(_mutex);
		if(!instance)
		{
			instance=new Singleton();
		}
		return instance;
	}

	void show()
	{
		std::cout<<"this is singleton!"<<std::endl;
	}
private:
	static Singleton* instance;
	static std::mutex _mutex;

	Singleton(){};
	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};

Singleton* Singleton::instance=nullptr;
std::mutex Singleton::_mutex;

但是这样写的效率就会及其底下，在GetInstance成员函数中，就为了解决一个初始化该类对象时的互斥问题，居然在GetInstance中增加互斥量，导致所有调用该函数的调用者线程都被互斥一下，这非常影响性能。因为除了初始化那个时刻，其他的时候完全不需要互斥。一旦初始化完毕，不管是否互斥调用GetInstance，这个if（！instance）条件都不会成立，从而完全可以确保初始化完毕之后，“instance=new Singleton()；”代码行绝不会被再次执行。

方法2

方法2也被称之为双重锁定，先给出代码

class Singleton
{
public:
	static Singleton* getInstance()
	{
		if(!instance)
		{
			std::lock_guard<std::mutex> lock(_mutex);
			if(!instance)
			{
				instance=new Singleton();
			}
		}
		return instance;
	}

	void show()
	{
		std::cout<<"this is singleton!"<<std::endl;
	}
private:
	static Singleton* instance;
	static std::mutex _mutex;

	Singleton(){};
	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};

Singleton* Singleton::instance=nullptr;
std::mutex Singleton::_mutex;

可以看到，对比上述方法，仅仅只是在原来的代码上多加了一层判断if(!instance)而已

为什么呢？

首先，我们需要明白一件事：

• 如果if(instance！=NULL)条件成立，则instance一定被创建过了，这是没问题的
• 但是如果if(!instance)条件成立，则instance则不一定被创建过，原因就是上述多线程的竞态问题

那么问题来了

首先，使用互斥锁可以避免竞态问题的出现，但是会代码效率问题，但是如果我们此时在外层多加一层判断，那么一旦instance被创建成功后，因为最外面有一个条件判断if （instance ==NULL）在，这样就不会每次调用GetInstance都会创建一次互斥量。也就是说，平常的调用根本就执行不到创建互斥量的代码，而是直接执行“return instance；”，这样调用者就能够直接拿到这个单例类的对象，所以肯定提高了执行GetInstance的效率。 

综上所示，互斥锁解决了多线程对单例对象创建的竞态问题，而双重判断解决了互斥锁带来的效率问题