Tsai笔记：C++设计模式学习（2）—— 单例模式（Singleton）

Tsai笔记：C++设计模式学习（2）—— 单例模式（Singleton）

设计模式的系列笔记链接如下：

 

Tsai笔记：C++设计模式学习（1）—— 设计模式介绍及分类

Tsai笔记：C++设计模式学习（2）—— 单例模式（Singleton）

Tsai笔记：C++设计模式学习（3）—— 享元模式（Flyweight）

Tsai笔记：C++设计模式学习（4）—— 工厂模式方法（Factory Method）

Tsai笔记：C++设计模式学习（5）—— 抽象工厂模式（Abstract Factory）

Tsai笔记：C++设计模式学习（6）—— 原型模式（ProtoType）

Tsai笔记：C++设计模式学习（7）—— 构建器（Builder）

 

一、模式定义

 单例模式：保证一个类仅有一个实例，并提供一个该实例的全局访问点。                                     ——《设计模式》Gof

二、要点总结

• 全局只有一个实例：static 特性；把构造函数设为 private，禁止用户自己声明并定义实例；实例构造器可以设置为protected以允许子类派生；
• 线程安全：正确使用双检查锁；  
• 禁止赋值和拷贝构造函数：因为这可能会导致多个对象实例，与Singleton模式的初衷违背；
• 用户通过接口获取实例：使用 static 类成员函数

三、C++ 代码呈现

1、 有缺陷的懒汉式

//SingleTon_V1.h
#include <iostream>
/*
	V1:
	1. 线程不安全
	2. 内存泄漏
*/

class Singleton_V1 {
private:
	Singleton_V1();
	Singleton_V1(Singleton_V1&) = delete;
	Singleton_V1& operator=(const Singleton_V1&) = delete;
	static Singleton_V1* m_instance_ptr;
public:
	~Singleton_V1();
	static Singleton_V1* get_instance();
};

Singleton_V1::Singleton_V1() {
	std::cout << "constructor called!" << std::endl;
}

Singleton_V1::~Singleton_V1() {
	std::cout << "destructor called!" << std::endl;
}

Singleton_V1* Singleton_V1::m_instance_ptr = nullptr;

Singleton_V1* Singleton_V1::get_instance() {
	if (m_instance_ptr == nullptr) {
		m_instance_ptr = new Singleton_V1;
	}
	return m_instance_ptr;
}

 测试函数：

#include <SingleTon_V1.h>

int main() {
	Singleton_V1* instance = Singleton_V1::get_instance();
	Singleton_V1* instance_2 = Singleton_V1::get_instance();
	return 0;
}

 输出结果为：

constructor called!

结果分析：

1. 线程安全问题：当多线程获取单例时有可能引发竞态条件：第一个线程在if中判断m_instance_ptr是空的，于是开始实例化单例;同时第2个线程也尝试获取单例，这个时候判断m_instance_ptr还是空的，于是也开始实例化单例;这样就会实例化出两个对象,这就是线程安全问题的由来; 解决办法：加锁
2. 内存泄漏问题：注意到类中只负责new出对象，却没有负责delete对象，因此只有构造函数被调用，析构函数却没有被调用;因此会导致内存泄漏。解决办法：使用共享指针;

2、 线程安全、内存安全的懒汉式单例（使用智能指针，双检查锁）

//SingleTon_V2.h
/*
	V2:
	1. 线程安全，但锁的代价过高
	2. 内存不泄漏
*/

class Singleton_V2 {
private:
	Singleton_V2();
	static std::shared_ptr<Singleton_V2> m_instance_ptr;
	static std::mutex m_mutex;

public:
	~Singleton_V2();
	Singleton_V2(Singleton_V2&) = delete;
	Singleton_V2& operator=(const Singleton_V2&) = delete;
	static std::shared_ptr<Singleton_V2> get_instance();
};

std::shared_ptr<Singleton_V2> Singleton_V2::m_instance_ptr = nullptr;
std::mutex Singleton_V2::m_mutex;

std::shared_ptr<Singleton_V2> Singleton_V2::get_instance() {
	//线程安全版本，但锁的代价过高
	//std::lock_guard<std::mutex> lk(m_mutex);
	//if (m_instance_ptr == nullptr) {
	//	m_instance_ptr = std::shared_ptr<Singleton_V2>(new Singleton_V2);
	//}
    
    //双检查锁
	if (m_instance_ptr == nullptr) {
		std::lock_guard<std::mutex> lk(m_mutex);
		if (m_instance_ptr == nullptr) {
			m_instance_ptr = std::shared_ptr<Singleton_V3>(new Singleton_V3);
		}
	}
	return m_instance_ptr;
}

Singleton_V2::Singleton_V2() {
	std::cout << "constructor called!" << std::endl;
}

Singleton_V2::~Singleton_V2() {
	std::cout << "destructor called!" << std::endl;
}

 测试函数：

#include <SingleTon_V2.h>

int main() {
	std::shared_ptr<Singleton_V2> instance = Singleton_V2::get_instance();
	std::shared_ptr<Singleton_V2> instance_2 = Singleton_V2::get_instance();
	return 0;
}

 输出结果为：

constructor called!
destructor called!

结果分析：

优点：

• 基于shared_ptr：用了C++比较倡导的 RAII思想，用对象管理资源，当 shared_ptr 析构的时候，new 出来的对象也会被 delete掉。以此避免内存泄漏。
• 加双检查锁：使用互斥量来达到线程安全。这里使用了两个 if判断语句的技术称为双检锁；好处是只有判断指针为空的时候才加锁，避免每次调用 get_instance的方法都加锁，锁的开销毕竟还是有点大的，从而避免了开销。

缺点：

• 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束； 使用锁也有开销； 同时代码量也增多了；
• 在某些平台（与编译器和指令集架构有关），双检锁会失效！

3、 最推荐的懒汉式单例(magic static )——局部静态变量

//SingleTon_V3.h
/*
	V3:
	1. 进阶版
*/

class Singleton_V3
{
public:
	~Singleton_V3();
	Singleton_V3(const Singleton_V3&) = delete;
	Singleton_V3& operator=(const Singleton_V3&) = delete;

	static Singleton_V3& get_instance();

private:
	Singleton_V3();
};

Singleton_V3::~Singleton_V3() {
	std::cout << "destructor called!" << std::endl;
}

Singleton_V3::Singleton_V3() {
	std::cout << "constructor called!" << std::endl;
}

Singleton_V3& Singleton_V3::get_instance() {
	static Singleton_V3 instance;
	return instance;
}

 测试函数：

#include <SingleTon_V3.h>

int main() {
	Singleton_V3& instance_1 = Singleton_V3::get_instance();
	Singleton_V3& instance_2 = Singleton_V3::get_instance();
	return 0;
}

 输出结果为：

constructor called!
destructor called!

这是最推荐的一种单例实现方式：

1. 通过局部静态变量的特性保证了线程安全；
2. 不需要使用共享指针，代码简洁；
3. 注意在使用的时候需要声明单例的引用 Singleton_V3&才能获取对象。

另外网上有人的实现返回指针而不是返回引用

static Singleton_V3* Singleton_V3::get_instance(){
    static Singleton_V3 instance;
    return &instance;
}

这样做并不好，理由主要是无法避免用户使用delete instance导致对象被提前销毁。还是建议使用返回引用的方式。