纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

C++ 单例模式 C++ 单例模式的几种实现方式研究

  2021-03-30 我要评论

单例模式

单例模式可以说设计模式中最常应用的一种模式了据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人可能不会想到要去应用单例模式面对单例模式适用的情况可能会优先考虑使用全局或者静态变量的方式这样比较简单也是没学过设计模式的人所能想到的最简单的方式了。

一般情况下我们建立的一些类是属于工具性质的基本不用存储太多的跟自身有关的数据在这种情况下每次都去new一个对象即增加了开销也使得代码更加臃肿。其实我们只需要一个实例对象就可以。如果采用全局或者静态变量的方式会影响封装性难以保证别的代码不会对全局变量造成影响。

考虑到这些需要我们将默认的构造函数声明为私有的这样就不会被外部所new了甚至可以将析构函数也声明为私有的这样就只有自己能够删除自己了。在Java和C#这样纯的面向对象的语言中单例模式非常好实现直接就可以在静态区初始化instance然后通过getInstance返回这种就被称为饿汉式单例类。也有些写法是在getInstance中new instance然后返回这种就被称为懒汉式单例类但这涉及到第一次getInstance的一个判断问题。

下面的代码只是表示一下跟具体哪种语言没有关系。

单线程中:

Singleton* getInstance()
{
  if (instance == NULL)
    instance = new Singleton();
 
  return instance;
}

这样就可以了保证只取得了一个实例。但是在多线程的环境下却不行了因为很可能两个线程同时运行到if (instance == NULL)这一句导致可能会产生两个实例。于是就要在代码中加锁。

Singleton* getInstance()
{
  lock();
  if (instance == NULL)
  {
    instance = new Singleton();
  }
  unlock();

  return instance;
}

但这样写的话会稍稍映像性能因为每次判断是否为空都需要被锁定如果有很多线程的话就爱会造成大量线程的阻塞。于是大神们又想出了双重锁定。

Singleton* getInstance()
{
  if (instance == NULL)
  {
	lock();
  	if (instance == NULL)
  	{
    		instance = new Singleton();
  	}
  	unlock();
  }

  return instance;
}

这样只够极低的几率下通过越过了if (instance == NULL)的线程才会有进入锁定临界区的可能性这种几率还是比较低的不会阻塞太多的线程但为了防止一个线程进入临界区创建实例另外的线程也进去临界区创建实例又加上了一道防御if (instance == NULL)这样就确保不会重复创建了。

常用的场景

单例模式常常与工厂模式结合使用因为工厂只需要创建产品实例就可以了在多线程的环境下也不会造成任何的冲突因此只需要一个工厂实例就可以了。

优点
1.减少了时间和空间的开销(new实例的开销)。

2.提高了封装性使得外部不易改动实例。

缺点
1.懒汉式是以时间换空间的方式。

2.饿汉式是以空间换时间的方式。

C++实现代码

#ifndef _SINGLETON_H_
#define _SINGLETON_H_


class Singleton{
public:
static Singleton* getInstance();

private:
Singleton();
//把复制构造函数和=操作符也设为私有,防止被复制
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);

static Singleton* instance;
};

#endif


#include "Singleton.h"


Singleton::Singleton(){

}


Singleton::Singleton(const Singleton&){

}


Singleton& Singleton::operator=(const Singleton&){

}


//在此处初始化
Singleton* Singleton::instance = new Singleton();
Singleton* Singleton::getInstance(){
return instance;
}


#include "Singleton.h"
#include <stdio.h>


int main(){
Singleton* singleton1 = Singleton::getInstance();
Singleton* singleton2 = Singleton::getInstance();

if (singleton1 == singleton2)
fprintf(stderr,"singleton1 = singleton2\n");

return 0;
}

1 g++ -o client Singleton.cpp client.cpp

运行结果

下面给大家补充一下

单例模式有两种实现模式:

1)懒汉模式: 就是说当你第一次使用时才创建一个唯一的实例对象从而实现延迟加载的效果。

2)饿汉模式: 就是说不管你将来用不用程序启动时就创建一个唯一的实例对象。

所以从实现手法上看 懒汉模式是在第一次使用单例对象时才完成初始化工作。因为此时可能存在多线程竞态环境如不加锁限制会导致重复构造或构造不完全问题。

饿汉模式则是利用外部变量在进入程序入口函数之前就完成单例对象的初始化工作此时是单线程所以不会存在多线程的竞态环境故而无需加锁。

以下是典型的几种实现

一、 懒汉模式标准的 ”双检锁“ + ”自动回收“ 实现

class Singleton

{
public:
  static Singleton* GetInstance()
  {
    if (m_pInstance == NULL )
    {
      Lock(); // 加锁
      if (m_pInstance == NULL )
      {
        m_pInstance = new Singleton ();
      }
      UnLock(); // 解锁
    }
    return m_pInstance;
  }

  // 实现一个内嵌垃圾回收类  
  class CGarbo 
  {
  public:
    ~CGarbo()
    {
      if(Singleton::m_pInstance) 
        delete Singleton::m_pInstance;
    }
  };

  static CGarbo Garbo; // 定义一个静态成员变量程序结束时系统会自动调用它的析构函数从而释放单例对象

private:
  Singleton(){};
  Singleton(Singleton const&); 
  Singleton& operator=(Singleton const&); 

  static Singleton* m_pInstance;
};

Singleton* Singleton::m_pInstance = NULL;
Singleton::CGarbo Garbo;

二、静态局部变量的懒汉模式 而不是new在堆上创建对象避免自己回收资源。

这里仍然要注意的是局部变量初始化的线程安全性问题在C++0X以后要求编译器保证静态变量初始化的线程安全性可以不加锁。但C++ 0X以前仍需要加锁。

class Singleton
{
public:
  static Singleton* GetInstance()
  {
    Lock(); // not needed after C++0x 
    static Singleton instance; 
    UnLock(); // not needed after C++0x 

    return &instance;
  }

private:
  Singleton() {};
  Singleton(const Singleton &);
  Singleton & operator = (const Singleton &);
};

在懒汉模式里如果大量并发线程获取单例对象在进行频繁加锁解锁操作时必然导致效率低下。

三、饿汉模式基础版本

因为程序一开始就完成了单例对象的初始化所以后续不再需要考虑多线程安全性问题就可以避免懒汉模式里频繁加锁解锁带来的开销。

class Singleton
{
public:

  static Singleton* GetInstance()
  {
    return &m_instance;
  }

private:
  Singleton(){};
  Singleton(Singleton const&); 
  Singleton& operator=(Singleton const&); 

  static Singleton m_instance;
};

Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化

虽然这种实现在一定程度下能良好工作但是在某些情况下会带来问题 --- 就是在C++中 ”非局部静态对象“ 的 ”初始化“ 顺序 的 ”不确定性“ 参见Effective c++ 条款47。

考虑: 如果有两个这样的单例类将分别生成单例对象A, 单例对象B. 它们分别定义在不同的编译单元(cpp中) 而A的初始化依赖于B 【 即A的构造函数中要调用B::GetInstance() 而此时B::m_instance 可能还未初始化显然调用结果就是非法的 】 所以说只有B在A之前完成初始化程序才能正确运行而这种跨编译单元的初始化顺序编译器是无法保证的。

四、饿汉模式增强版本(boost实现)

在前面的方案中:饿汉模式中使用到了类静态成员变量但是遇到了初始化顺序的问题; 懒汉模式中使用到了静态局部变量但是存在着线程安全等问题。

boost 的实现方式是:单例对象作为静态局部变量然后增加一个辅助类并声明一个该辅助类的类静态成员变量在该辅助类的构造函数中初始化单例对象。以下为代码

class Singleton
{
public:
  static Singleton* GetInstance()
  {
    static Singleton instance;
    return &instance;
  }

protected:
  // 辅助代理类
  struct Object_Creator
  {
    Object_Creator()
    {
      Singleton::GetInstance();
    }
  };
  static Object_Creator _object_creator;

  Singleton() {}
  ~Singleton() {}
};

Singleton::Object_Creator Singleton::_object_creator;

首先代理类这个外部变量初始化时在其构造函数内部调用 Singleton::GetInstance();从而间接完成单例对象的初始化这就通过该代理类实现了饿汉模式的特性。

其次仍然考虑第三种模式的缺陷。 当A的初始化依赖于B 【 即A的构造函数中要调用B::GetInstance() 而此时B::m_instance 可能还未初始化显然调用结果就是非法的 】 现在就变为【在A的构造函数中要调用B::GetInstance() 如果B尚未初始化就会引发B的初始化】所以在不同编译单元内全局变量的初始化顺序不定的问题就随之解决。

最后关于使用懒汉还是饿汉模式我的理解:

如果这个单例对象构造十分耗时或者占用很多资源比如加载插件啊 初始化网络连接啊读取文件啊等等而有可能该对象程序运行时不会用到那么也要在程序一开始就进行初始化也是一种资源浪费吧。 所以这种情况懒汉模式(延迟加载)更好。

如果这个单例对象在多线程高并发环境下频繁使用性能要求较高那么显然使用饿汉模式来避免资源竞争提高响应速度更好。


相关文章

猜您喜欢

  • docker运行nginx使用daemon off 浅谈docker运行nginx为什么要使用daemon off

    想了解浅谈docker运行nginx为什么要使用daemon off的相关内容吗Godtoy在本文为您仔细讲解docker运行nginx使用daemon off的相关知识和一些Code实例欢迎阅读和指正我们先划重点:docker,nginx使用daemon,off下面大家一起来学习吧。..
  • java集合 Java集合总结

    想了解Java集合总结的相关内容吗sdr_zd在本文为您仔细讲解java集合的相关知识和一些Code实例欢迎阅读和指正我们先划重点:java集合,java集合总结,java集合介绍下面大家一起来学习吧。..

网友评论

Copyright 2020 www.Shellfishsoft.com 【贝软下载站】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式