学习《图说设计模式》单例模式——进阶

最新推荐文章于 2024-08-05 15:59:34 发布

Orange Wu

最新推荐文章于 2024-08-05 15:59:34 发布

阅读量206

点赞数 1

分类专栏：图说设计模式

原文链接：https://blog.csdn.net/yao_hou/article/details/105469336

版权

图说设计模式专栏收录该内容

13 篇文章 3 订阅

订阅专栏

查看原文档

C++ 单例模式

单例可能是最常用的简单的一种设计模式，实现方法多样，根据不同的需求有不同的写法; 同时单例也有其局限性，因此有很多人是反对使用单例的。本文对C++ 单例的常见写法进行了一个总结, 包括懒汉式、线程安全、单例模板等；按照从简单到复杂，最终回归简单的的方式循序渐进地介绍，并且对各种实现方法的局限进行了简单的阐述，大量用到了C++ 11的特性如智能指针, magic static，线程锁; 从头到尾理解下来，对于学习和巩固C++语言特性还是很有帮助的。

一、什么是单例

单例 Singleton 是设计模式的一种，其 特点是只提供唯一一个类的实例,具有全局变量 的特点，在任何位置都可以通过接口获取到那个唯一实例;
具体运用场景如：

设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;

二、C++单例的实现

2.1 基础要点

全局只有一个实例：static 特性，同时禁止用户自己声明并定义实例（把构造函数设为 private）
线程安全
禁止赋值和拷贝
用户通过接口获取实例：使用 static 类成员函数

2.2 C++ 实现单例的几种方式

2.2.1 有缺陷的懒汉式

懒汉式(Lazy-Initialization)的方法是直到使用时才实例化对象，也就说直到调用get_instance() 方法的时候才 new 一个单例的对象。好处是如果被调用就不会占用内存。

#include <iostream>
// version1:
// with problems below:
// 1. thread is not safe
// 2. memory leak

class Singleton{
private:
    Singleton(){
        std::cout<<"constructor called!"<<std::endl;
    }
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Singleton* m_instance_ptr;
public:
    ~Singleton(){
        std::cout<<"destructor called!"<<std::endl;
    }
    static Singleton* get_instance(){
        if(m_instance_ptr==nullptr){
              m_instance_ptr = new Singleton;
        }
        return m_instance_ptr;
    }
    void use() const { std::cout << "in use" << std::endl; }
};

Singleton* Singleton::m_instance_ptr = nullptr;

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

运行结果是

constructor called!

可以看到，获取了两次类的实例，却只有一次类的构造函数被调用，表明只生成了唯一实例，这是个最基础版本的单例实现，他有哪些问题呢？

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

2.2.2 线程安全、内存安全的懒汉式单例（智能指针，锁）

#include <iostream>
#include <memory> // shared_ptr
//使用智能指针头文件
#include <mutex>  // mutex
//提供了多种互斥操作，可以显式避免数据竞争

// version 2:
// with problems below fixed:
// 1. thread is safe now
// 2. memory doesn't leak

class Singleton
{
public:
    typedef std::shared_ptr<Singleton> Ptr;
    ~Singleton()
    {
        std::cout<<"destructor called!"<<std::endl;
    }
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Ptr get_instance()
    {

        // "double checked lock"
        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>(new Singleton);
            }
        }
        return m_instance_ptr;
    }


private:
    Singleton()
    {
        std::cout<<"constructor called!"<<std::endl;
    }
    static Ptr m_instance_ptr;
    static std::mutex m_mutex;
};

// initialization static variables out of class
Singleton::Ptr Singleton::m_instance_ptr = nullptr;
std::mutex Singleton::m_mutex;

int main(){
    Singleton::Ptr instance = Singleton::get_instance();
    Singleton::Ptr instance2 = Singleton::get_instance();
    return 0;
}

运行结果如下，发现确实只构造了一次实例，并且发生了析构。

constructor called!
destructor called!

shared_ptr和mutex都是C++11的标准，以上这种方法的优点是

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

不足之处在于：使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。

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

#include <iostream>

class Singleton
{
public:
	~Singleton() 
	{
		std::cout << "destructor called!" << std::endl;
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	static Singleton& get_instance() 
	{
		static Singleton instance;
		return instance;

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

int main(int argc, char *argv[])
{
	Singleton& instance_1 = Singleton::get_instance();
	Singleton& instance_2 = Singleton::get_instance();

	system("pause");
	return 0;
}

运行结果

constructor called!

这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。
C++静态变量的生存期是从声明到程序结束，这也是一种懒汉式。

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

通过局部静态变量的特性保证了线程安全 (C++11, GCC > 4.3, VS2015支持该特性);
不需要使用共享指针，代码简洁；
注意在使用的时候需要声明单例的引用 Single& 才能获取对象。

2.3 单例的模板

2.3.1 CRTP 奇异递归模板模式实现

代码示例如下：

// brief: a singleton base class offering an easy way to create singleton
#include <iostream>

template<typename T>
class Singleton
{
public:
    static T& get_instance()
    {
        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;
};

int main(int argc, char* argv[])
{
    DerivedSingle& instance1 = DerivedSingle::get_instance();
    DerivedSingle& instance2 = DerivedSingle::get_instance();
    return 0;
}

以上实现一个单例的模板基类，使用方法如例子所示意，子类需要将自己作为模板参数T 传递给 Singleton 模板; 同时需要将基类声明为友元，这样才能调用子类的私有构造函数。

基类模板的实现要点是：

构造函数需要是 protected，这样子类才能继承；
使用了奇异递归模板模式CRTP(Curiously recurring template pattern)
get instance 方法和 2.2.3 的static local方法一个原理。
在这里基类的析构函数可以不需要 virtual ，因为子类在应用中只会用 Derived 类型，保- - 证了析构时和构造时的类型一致

2.3.2 不需要在子类声明友元的实现方法

精髓在于使用一个代理类 token，子类构造函数需要传递token类才能构造，但是把 token保护其起来，然后子类的构造函数就可以是公有的了，这个子类只有 Derived(token)的这样的构造函数，这样用户就无法自己定义一个类的实例了，起到控制其唯一性的作用。代码如下。

#include <iostream>

template<typename T>
class Singleton
{
public:
    static T& get_instance() noexcept(std::is_nothrow_constructible<T>::value)
    {
        static T instance{token()};
        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;
};

int main(int argc, char* argv[]){
    DerivedSingle& instance1 = DerivedSingle::get_instance();
    DerivedSingle& instance2 = DerivedSingle::get_instance();
    return 0;
}

三、何时应该使用或者不使用单例

你需要系统中只有唯一一个实例存在的类的全局变量的时候才使用单例

如果使用单例，应该用什么样子的

How to create the best singleton:
The smaller, the better. I am a minimalist
Make sure it is thread safe
Make sure it is never null
-Make sure it is created only once
Lazy or system initialization? Up to your requirements
Sometimes the OS or the JVM creates singletons for you (e.g. in Java every class - definition is a singleton)
Provide a destructor or somehow figure out how to dispose resources
Use little memory
越小越好，越简单越好，线程安全，内存不泄露

四、懒汉式”与“饿汉式”的区别

“懒汉式”是在你真正用到的时候才去建这个单例对象：

public class Singleton
{
    private Singleton(){}
    private static Singleton singleton = null；  //不建立对象
    public static synchronized Singleton getInstance()
    {
    	if(singleton == null)
        {        //先判断是否为空                
        	singleton = new Singleton ();  //懒汉式做法
		}
		return singleton;
     }
}

饿汉式”是在不管你用的用不上，一开始就建立这个单例对象

public class Singleton
{
    public Singleton(){}
    private static Singleton singleton = new Singleton();  //建立对象
    public static Singleton getInstance()
    {
        return singleton;	//直接返回单例对象    
    }
}