C++设计模式 ---- 单例模式

于 2019-08-13 19:54:33 发布
阅读量327 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Disremembrance/article/details/99326991
版权

设计模式概念

设计模式就是在解决某一类问题时，有一个既定的、优秀的代码框架可以直接使用。
优点如下：

  • 代码更易于维护，代码的可读性，复用性，可移植性，健壮性会更好
  • 到软件的原有需求有变更或者增加新的需求时，合理的设计模式的应用，能够做到软件设计要求的“开—闭原则”，即对修改关闭，对扩展开发，使软件原有功能修改，新功能扩充非常灵活
  • 合理的设计模式的选择，会使软件设计更加模块化，积极的做到软件设计遵循的根本原则 “高内聚，低耦合”

单例模式

1、概念

单例模式指的是，无论怎么获取，用户都只能得到该类类型的唯一一个实例对象。所以，在设计单例模式时就要满足下面三个条件

  • 构造函数私有化，这样在外部就不能任意定义该类型的对象了
  • 定义一个该类的唯一对象
  • 通过一个static静态成员方法返回唯一的对象实例
2、饿汉单例模式

代码实现如下：

class Singleton
{
public:
	static Singleton *getSingleObj()
	{
		return &single;
	}
private:
	static Singleton single;
	Singleton() { cout << "Singleton()" << endl; }
	~Singleton() { cout << "~Singleton()" << endl; }
	//防止外部用拷贝构造函数产生新的对象
	Singleton(const Singleton&);
};

Singleton Singleton::single;

int main()
{
	//没有办法定义新对象，只能用作用域调
	Singleton *p1 = Singleton::getSingleObj();
	Singleton *p2 = Singleton::getSingleObj();
	Singleton *p3 = Singleton::getSingleObj();

	cout << p1 << "  " << p2 << "  " << p3 << endl;
	return 0;
}

打印结果如下，可以看到三次获取到的都是同一个对象实例，指针得到是同一个地址。
在这里插入图片描述
**饿汉式单例模式：****程序启动时就实例化了该对象，并不是等待第一次使用该对象时再进行实例化。**如果在代码运行过程中没有用到该实例对象，那它就被浪费掉了。

3、懒汉单例模式

代码实现如下：

class Singleton
{
public:
	static Singleton *getSingleObj()
	{
		if (single == nullptr)
		{
			single = new Singleton();
		}
		return single;
	}
private:
	static Singleton *single;
	Singleton() { cout << "Singleton()" << endl; }
	~Singleton() { cout << "~Singleton()" << endl; }
	//防止外部用拷贝构造函数产生新的对象
	Singleton(const Singleton&);
};

Singleton* Singleton::single = nullptr;

int main()
{
	//没有办法定义新对象，只能用作用域调
	Singleton *p1 = Singleton::getSingleObj();
	Singleton *p2 = Singleton::getSingleObj();
	Singleton *p3 = Singleton::getSingleObj();

	cout << p1 << "  " << p2 << "  " << p3 << endl;
	return 0;
}

打印结果如下，可以看到三次获取的都是同一个对象实例，指针指向的是同一个地址，符合单例模式的要求。
在这里插入图片描述
懒汉单例模式：等到第一次使用对象的时候再来进行对象的实例化。所以在程序启动的时候，只对single指针初始化了空值，等到第一次调用getSingleObj函数时，此时single指针恰好为nullptr，那就对single进行对象的实例化。
但是根据打印结果可以看出，先是调用了析构，然后是三个相同的地址，就完了。瞬间有没有感觉缺了点什么哈哈哈
对嘛，C++中有构造就要有析构，可是这里的析构去哪里了。没有了析构，就会导致有内存泄漏的问题

int main()
{
	//没有办法定义新对象，只能用作用域调
	Singleton *p1 = Singleton::getSingleObj();
	Singleton *p2 = Singleton::getSingleObj();
	Singleton *p3 = Singleton::getSingleObj();
	cout << p1 << "  " << p2 << "  " << p3 << endl;
	delete p1;//delete  p1指向的对象，析构对象并且释放堆上的内存
	return 0;
}

但是这种方式似乎有点不太完美。如果把释放资源的工作交给写这段代码的人，难免就会有忘记delete的时候。所以这样问题还是很大的哟！
所以可以根据静态对象在函数结束时自动析构的特点来改变一下代码：

//可以析构的懒汉模式
class Singleton
{
public:
	static Singleton *getSingleObj()
	{
		if (single == nullptr)
		{
			single = new Singleton();
		}
		return single;
	}
private:
	static Singleton *single;
	Singleton() { cout << "Singleton()" << endl; }
	~Singleton() { cout << "~Singleton()" << endl; }
	//防止外部用拷贝构造函数产生新的对象
	Singleton(const Singleton&);

	//定义一个嵌套类，在该类的析构函数中，自动释放外层类的资源
	class Release
	{
	public:
		~Release() { delete single; }
	};

	//通过静态对象在程序结束时自动调用析构的特点，来释放外层类的对象资源
	static Release release;
};

Singleton* Singleton::single = nullptr;
Singleton::Release Singleton::release;

可是Single不也是static类型的吗，那为什么它在程序结束时，不调用下析构呢？因为它在getSingleObj中new了一个对象，所以它就在堆上开辟了一段内存，这样的话就必须要手动delete去释放掉这些内存，而不会去调用相应的析构函数了。
所以定义了一个嵌套类的静态对象，在该嵌套类的析构中实现外层类的delete。等到程序结束时先调用嵌套类的析构然后去调用外层类的析构。
最终打印结果如下：
在这里插入图片描述

线程安全的单例模式

在实际编程中，多线程时经常用到的一种编程方式。多线程的情况下虽然为服务器提高了效率，但是很容易出现资源的竞争情况。所以多线程时要考虑代码的安全性，不然就需要进行线程的互斥操作。那么懒汉模式和饿汉模式在多线程环境中，是否是线程安全的单例模式？

1、饿汉单例模式的线程安全特性

饿汉单例模式中，事先定义好了一个static对象，而这个对象是在程序启动时，main函数运行之前就已经初始化好的。因此，它不存在线程安全问题，所以可以放心在多线程环境中使用。

2、懒汉单例模式的线程安全特性

懒汉单例模式下，获取单例对象的方法如下：

static Singleton *getSingleObj()
	{
		if (single == nullptr)
		{
			single = new Singleton();
		}
		return single;
	}

懒汉模式下，对象的初始化是在第一次使用时才进行的。所以，如果此时有两个或多个线程都是第一次使用对象，那就会出现竞争。
single = new Singleton();这句代码会做三件事情：开辟内存，调用构造函数，给single指针赋值。那么在多线程中就会可能出现如下问题：

  • 线程A先调用了getSingleObj函数，由于single此时为nullptr，所以可以进入语句
  • new 操作先给开辟了内存，这是A线程的可以运行的时间片结束了，又切换到了B线程
  • B线程调用getSingleObj函数时，single也为nullptr，所以就又开始new操作

这样两个线程都试图去new一个新的对象，这样就不符合单例模式的要求了。所以，和在Linux中学的一样，此时就要对这段代码进行互斥操作了。

class Singleton
{
public:
	static Singleton* getSingleObj()
	{
		// 获取互斥锁
		pthread_mutex_lock(&mutex);
		if (nullptr == single)
		{
			single = new Singleton();
		}
		// 释放互斥锁
		pthread_mutex_unlock(&mutex);
		return single;
	}
private:
	static Singleton*single;
	Singleton() { cout << "Singleton()" << endl; }
	~CSingleton() 
	{ 
		pthread_mutex_destroy(&mutex); // 释放锁
		cout << "~Singleton()" << endl; 
	}
	Singleton(const Singleton&);

	class Release
	{
	public:
		~Release() { delete single; }
	};
	static Release release;
	
	// 定义线程间的互斥锁
	static pthread_mutex_t mutex;
};
Singleton* Singleton::single = nullptr;
Singleton::Release Singleton::release;
// 互斥锁的初始化
pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;

int main()
{
	Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	Singleton *p3 = Singleton::getInstance();
	return 0;
}

这种情况下，虽然问题可以解决，是一个线程安全的单例模式了。但是除过第一次调用时，起了很大的作用外，剩下时候就把时间一直浪费在加锁解锁上了。但事实上，第一次调用后，锁好像也没有什么用了。
所以，改进如下：

class Singleton
{
public:
	static Singleton* getSingleObj()
	{
		if (nullptr == single)
		{	
			// 获取互斥锁
			pthread_mutex_lock(&mutex);
			if (nullptr == single)
			{
				single = new Singleton();
			}
			// 释放互斥锁
			pthread_mutex_unlock(&mutex);
		}
		return single;
	}
private:
	static Singleton*single;
	Singleton() { cout << "Singleton()" << endl; }
	~CSingleton() 
	{ 
		pthread_mutex_destroy(&mutex); // 释放锁
		cout << "~Singleton()" << endl; 
	}
	Singleton(const Singleton&);

	class Release
	{
	public:
		~Release() { delete single; }
	};
	static Release release;
	
	// 定义线程间的互斥锁
	static pthread_mutex_t mutex;
};
Singleton* Singleton::single = nullptr;
Singleton::Release Singleton::release;
// 互斥锁的初始化
pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;

int main()
{
	Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	Singleton *p3 = Singleton::getInstance();
	return 0;
}

这样既满足了效率，又满足了线程安全的问题！但是也可以将互斥锁的操作封装成一个类，这样在代码中就更能体现出C++的OOP思想了。

// 对互斥锁操作的封装
class Mutex
{
public:
	Mutex(){pthread_mutex_init(&mutex, NULL);}  // 初始化锁
	~Mutex(){pthread_mutex_destroy(&mutex);}  // 销毁锁 
	void lock(){pthread_mutex_lock(&mutex);}  // 获取锁
	void unlock(){pthread_mutex_unlock(&mutex);}  // 释放锁
private:
	pthread_mutex_t mutex;
};

class Singleton
{
public:
	static Singleton* getSingleObj()
	{
		if (nullptr == single)
		{
			// 获取互斥锁
			mutex.lock();
			/* 
			这里需要再添加一个if判断，否则当两个
			线程都进入这里，又会多次new对象，不符合
			单例模式的设计
			*/
			if(nullptr == single)
			{
				single = new Singleton();
			}
			// 释放互斥锁
			mutex.unlock();
		}
		
		return single;
	}
private:
	static Singleton*single;
	Singleton() { cout << "Singleton()" << endl; }
	~Singleton() { cout << "~Singleton()" << endl;}
	Singleton(const Singleton&);

	class Release
	{
	public:
		~Release() { delete single; }
	};
	static Release release;
	
	//线程间的静态互斥锁
	static Mutex mutex;
};
Singleton* Singleton::single = nullptr;
Singleton::Release Singleton::release;
// 定义互斥锁静态对象
Mutex Singleton::mutex;

int main()
{
	Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	Singleton *p3 = Singleton::getInstance();
	return 0;
}

注：对于static静态局部变量的初始化，编译器会自动对它的初始化进行加锁和解锁控制，使静态局部变量的初始化成为线程安全的操作，不用担心多个线程都会初始化静态局部变量，这样的操作通常是线程安全的。

单例模式的使用场景

使用单例模式的作用如下：

  1. 可以控制资源的使用，通过线程同步来控制资源的并发访问
  2. 控制实例产生的数量，从而达到节约资源
  3. 作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的情况下，让多个不相关的两个线程或者进程之间实现通信。
    最简单来说，如果你在该系统中只需要有一个该类型的对象，那就可以使用单例模式。
    比如Win下的文件资源管理器，控制面板，任务管理器，回收站等，这都是唯一存在的。再比如，数据库的连接池的设计一般采用单例模式，数据库连接是一种数据库资源。数据库连接池属于重量级资源，一个引用中只需要保留一份即可，这样既节省了资源又方便管理。所以数据库的连接池采用单例模式设计是一个非常好的选择。
    实际上，配置信息类、管理类、控制类、门面类、代理类都通常被设计为单例模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值