23种设计模式——单例模式对象性能
Posted J-A
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了23种设计模式——单例模式对象性能相关的知识，希望对你有一定的参考价值。
文章目录
亦称： 单件模式、Singleton
意图
单例的特点是只提供唯一一个类的实例，具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例。
什么时候使用单例
具体运用场景如：
-
设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
-
数据池，用来缓存数据的数据结构，需要在一处写，多处读取;
单例模式的实现
所有单例的实现都包含以下两个相同的步骤：
- 将默认构造函数设为私有， 防止其他对象使用单例类的
new运算符。 - 新建一个静态构建方法作为构造函数。 该函数会 “偷偷” 调用私有构造函数来创建对象， 并将其保存在一个静态成员变量中。 此后所有对于该函数的调用都将返回这一缓存对象。
如果你的代码能够访问单例类， 那它就能调用单例类的静态方法。 无论何时调用该方法， 它总是会返回相同的对象。
1、有缺陷的懒汉式
懒汉式的方法是直到使用时才实例化对象，也就是直到调用GetInstance()方法时才new一个单例的对象。
class Singleton
protected:
Singleton(const std::string value) :value_(value)
static Singleton* singleton_;
std::string value_;
public:
Singleton(Singleton &other) = delete;
void operator=(const Singleton &) = delete;
static Singleton *GetInstance(const std::string& value);
void SomeBusinessLogic()
// ...
std::string value() const
return value_;
;
Singleton* Singleton::singleton_ = nullptr;;
Singleton *Singleton::GetInstance(const std::string& value)
if (singleton_ == nullptr)
singleton_ = new Singleton(value);
return singleton_;
这是个最基础版本的实现，存在以下2个问题：
1）线程安全的问题，当多线程获取单例时有可能引发竞态条件：第一个线程在if中判断 singleton_是空的，于是开始实例化单例；同时第2个线程也尝试获取单例，这个时候判断singleton_还是空的，于是也开始实例化单例；这样就会实例化出两个对象，这就是线程安全问题的由来。解决办法:加锁；
2）内存泄漏，注意到类中只负责new出对象，却没有负责delete对象，因此只有构造函数被调用，析构函数却没有被调用；因此会导致内存泄漏。解决办法： 使用共享指针;
因此，这里提供一个改进的，线程安全的、使用智能指针的实现;
2、线程安全、内存安全的懒汉式单例 （智能指针，锁）
class Singleton
public:
//typedef std::shared_ptr<Singleton> Ptr;
using Ptr = std::shared_ptr<Singleton>;
~Singleton()
std::cout<<"destructor called!"<<std::endl;
Singleton(Singleton&)=delete;
Singleton& operator=(const Singleton&)=delete;
static Ptr getInstance()
// 双重锁
if(m_pInstance==nullptr)
std::lock_guard<std::mutex> lk(m_mutex);
if(m_pInstance == nullptr)
m_pInstance = std::shared_ptr<Singleton>(new Singleton);
return m_pInstance;
private:
Singleton()
std::cout << "constructor called!" << std::endl;
private:
static Ptr m_pInstance;
static std::mutex m_mutex;
;
// initialization static variables out of class
Singleton::Ptr Singleton::m_pInstance = nullptr;
std::mutex Singleton::m_mutex;
shared_ptr和mutex都是C++11的标准，以上这种方法的优点是：
1）基于 shared_ptr, 用了C++比较倡导的 RAII思想，用对象管理资源,当 shared_ptr 析构的时候，new 出来的对象也会被 delete掉。以此避免内存泄漏。
2）加了锁，使用互斥量来达到线程安全。这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 get_instance的方法都加锁，锁的开销毕竟还是有点大的。
不足之处在于： 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！
因此这里还有第三种的基于 Magic Static的方法达到线程安全。
3、最推荐的懒汉式单例(magic static )——局部静态变量
class Singleton
private:
Singleton() = default;
~Singleton() = default;
public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
static Singleton& GetInstance()
static Singleton instance;
return instance;
;
这种方法又叫做 Meyers’ SingletonMeyer’s的单例， 是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的。所用到的特性是在C++11标准中的Magic Static特性：
If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.
如果当变量在初始化的时候，并发同时进入声明语句，并发线程将会阻塞等待初始化结束。
这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。
C++静态变量的生存期 是从声明到程序结束，这也是一种懒汉式。
这是最推荐的一种单例实现方式：通过局部静态变量的特性保证了线程安全 , 不需要使用共享指针，代码简洁；注意在使用的时候需要声明单例的引用 Singleton& 才能获取对象。
另外网上有人的实现返回指针而不是返回引用
static Singleton* get_instance()
static Singleton instance;
return &instance;
这样做并不好，理由主要是无法避免用户使用delete instance导致对象被提前销毁。还是建议大家使用返回引用的方式。
4、单例模式模板类的实现
template<typename T>
class Singleton
public:
static T& getInstance()
static T instance;
return instance;
virtual ~Singleton()
std::cout << "destructor called!" << std::endl;
Singleton(const Singleton&) = delete;
Singleton& operator =(const Singleton&) = delete;
protected:
Singleton()
std::cout << "constructor called!" << std::endl;
;
/********************************************/
// Example:
// 1.friend class declaration is requiered!
// 2.constructor should be private
class DerivedSingle : public Singleton<DerivedSingle>
// !!!! attention!!!
// needs to be friend in order to
// access the private constructor/destructor
friend class Singleton<DerivedSingle>;
public:
DerivedSingle(const DerivedSingle&) = delete;
DerivedSingle& operator =(const DerivedSingle&) = delete;
private:
DerivedSingle() = default;
;
以上实现一个单例的模板基类，使用方法如例子所示意，子类需要将自己作为模板参数T 传递给 Singleton 模板; 同时需要将基类声明为友元，这样才能调用子类的私有构造函数。
基类模板的实现要点是：
-
构造函数需要是 protected，这样子类才能继承；
-
使用了奇异递归模板模式
CRTP(Curiously recurring template pattern)
在这里基类的析构函数可以不需要 virtual ，因为子类在应用中只会用 Derived 类型，保证了析构时和构造时的类型一致。
5、不需要在子类声明友元的实现方法
在 stackoverflow上， 有大神给出了不需要在子类中声明友元的方法，在这里一并放出；精髓在于使用一个代理类 token，子类构造函数需要传递token类才能构造，但是把 token保护其起来， 然后子类的构造函数就可以是公有的了，这个子类只有 Derived(token)的这样的构造函数，这样用户就无法自己定义一个类的实例了，起到控制其唯一性的作用。
template<typename T>
class Singleton
public:
// C++ STL的std::is_nothrow_constructible模板用于检查给定类型T是否是带有参数集的可构造类型，并且众所周知，它不会引发任何异常。如果T为可构造类型，则返回布尔值true，否则返回false。
static T& getInstance() noexcept(std::is_nothrow_constructible<T>::value)
static T instancetoken();
return instance;
virtual ~Singleton() = default;
Singleton(const Singleton&) = delete;
Singleton& operator =(const Singleton&) = delete;
protected:
struct token ; // helper class
Singleton() noexcept = default;
;
/********************************************/
// Example:
// constructor should be public because protected `token` control the access
class DerivedSingle : public Singleton<DerivedSingle>
public:
DerivedSingle(token)
std::cout << "destructor called!" << std::endl;
~DerivedSingle()
std::cout << "constructor called!" << std::endl;
DerivedSingle(const DerivedSingle&) = delete;
DerivedSingle& operator =(const DerivedSingle&) = delete;
;
单例模式的优缺点
| 优点 | 缺点 |
|---|---|
| 保证一个类只有一个实例 | 违反了_单一职责原则_。 该模式同时解决了两个问题。 |
| 获得了一个指向该实例的全局访问节点 | 单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。 |
| 仅在首次请求单例对象时对其进行初始化 | 单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。 |
以上是关于23种设计模式——单例模式对象性能的主要内容，如果未能解决你的问题，请参考以下文章