c++单例模式扫盲

单例模式:

概念:单例模式是一种常见的软件设计模式。它的核心结构只包含一个被称为单例的特殊类。
它的目的是保证一个类仅有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享

应用场景:有一些对象只需要一个,如:对话框、系统日志、显卡等设备的驱动程序对象、一台PC连接一个键盘。单例模式有3种实现方式:懒汉式、饿汉式和双重锁(改进的懒汉式)的形式。

简单来说:
懒汉:第一次用到类的实例的时候才回去实例化

饿汉:单例类定义的时候就进行实例化
在这里插入图片描述

实现方式:
1.构造函数私有化
2.公有静态类对象指针
3.产生静态类对象指针的公有函数

分类:
懒汉式:在需要的时候才进行初始化
优点:避免内存消耗
缺点:需要加锁,影响执行效率

饿汉式:一开始就进行初始化
优点:不需要加锁,执行速度快
缺点:会造成内存消耗

注意:
1.双检索机制--->懒汉式,在判断之前需要在加上一个锁
2.资源//singleton.h


#pragma once
#include <mutex>


class singleton
{
public:
    static singleton* singleton_;
    static singleton* getInstance();
    void doSomeThing();
private:
    static std::mutex mutex_;
    singleton();
    ~singleton();
};
//singleton.cpp----此为懒汉式
#include "pch.h"
#include <iostream>
#include "singleton.h"

singleton *singleton::singleton_ = NULL;
std::mutex singleton::mutex_;

singleton::singleton()
{
}


singleton::~singleton()
{
    if (singleton_)
    {
        delete singleton_;
        singleton_ = NULL;
    }
}

singleton* singleton::getInstance()
{
    if (singleton_==NULL)
    {
        std::lock_guard<std::mutex> lock(mutex_);
        if (singleton_==NULL)
        {
            singleton_ = new singleton();
        }
    }
    return singleton_;
}

void singleton::doSomeThing()
{
    std::cout << "do some thing!";
}
//singleton.cpp----此为恶汉式
#include "pch.h"
#include <iostream>
#include "singleton.h"

singleton *singleton::singleton_ =  new singleton();;
std::mutex singleton::mutex_;

singleton::singleton()
{
}


singleton::~singleton()
{
    if (singleton_)
    {
        delete singleton_;
        singleton_ = NULL;
    }
}

singleton* singleton::getInstance()
{
    return singleton_;
}

void singleton::doSomeThing()
{
    std::cout << "do some thing!";
}

//测试代码

#include "pch.h"
#include <iostream>
#include "singleton.h"

int main()
{
    singleton::getInstance()->doSomeThing();
    getchar();
}

上面的是将声明和实现分开了,现在把把声明实现放一起看看

  1. 懒汉式
    构造函数声明为private或者protect防止被外部函数实例化,内部保存一个private static的类指针保存唯一的实例,实例的动作有一个public的类方法实现。代码如下:
class singleton   //实现单例模式的类  
  {  
  private:  
      singleton(){}  //私有的构造函数  
      static singleton* Instance;  
  public:  
      static singleton* GetInstance()  
      {  
          if (Instance == NULL) //判断是否第一调用  
              Instance = new singleton();  
          return Instance;  
      }  
  }; 

缺点:这个实现在单线程下是正确的,但在多线程情况下,如果两个线程同时首次调用GetInstance方法且同时检测到Instance是NULL,则两个线程会同时构造一个实例给Instance,这样就会发生错误

  1. 改进的懒汉式(双重检查锁)
     思路:只有在第一次创建的时候进行加锁,当Instance不为空的时候就不需要进行加锁的操作。代码如下:
class singleton   //实现单例模式的类  
  {  
  private:  
      singleton(){}  //私有的构造函数  
      static singleton* Instance;  
        
  public:  
      static singleton* GetInstance()  
      {  
          if (Instance == NULL) //判断是否第一调用  
          {   
              Lock(); //表示上锁的函数  
              if (Instance == NULL)  
              {  
                  Instance = new singleton();  
              }  
              UnLock() //解锁函数  
          }             
          return Instance;  
      }  
  };  
  1. 饿汉式
    饿汉式的特点是一开始就加载了,如果说懒汉式是“时间换空间”,那么饿汉式就是“空间换时间”,因为一开始就创建了实例,所以每次用到的之后直接返回就好了。饿汉模式是线程安全的
class singleton
{
public:
	static singleton& GetInstance();
protected:

	singleton();
	~singleton();

private:
	static singleton _instance;

};



singleton singleton::_instance;
singleton::singleton()
{
	std::cout << "enter singleton::singleton() " << endl;
}

singleton::~singleton()
{
	std::cout << "enter singleton::~v() " << endl;
}

singleton& singleton::GetInstance()
{
	std::cout << "singleton::GetInstance()" << endl;
	return _instance;
}

由前述可知,饿汉式在main被载入后,就会因为其是静态类成员而被初始化,当然也就会在类域内调用构造函数。只不过形式上声明和定义还是要分开的:静态类成员一般在类内声明,在类外初始化。

private:
	static singleton _instance;

是声明,在类外

singleton singleton::_instance;

才完成了初始化工作,不能没有他,不写会报错
在这里插入图片描述

另外一篇是关于线程安全的,讨论到了原子操作和volatile、内存栅栏等等
https://www.jianshu.com/p/69eef7651667

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页