设计模式之单例模式

设计模式之单例模式

简介

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

类图

优点：

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用（比如写文件操作）。

缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

懒汉式（线程不安全）

#pragma once

#include 
#include 
using namespace std;

class LazySingleton
{
private:
	LazySingleton();//私有构造函数
public:
	static LazySingleton* getInstance();//公开的获取静态实例方法
	static void getName();
private:
	static LazySingleton* _instance;//私有的唯一的静态实例
	static string _name;
};

#include "Singleton.h"
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
string Singleton::_name = "test1";

Singleton::Singleton()
{
    _instance = NULL;
    _name = "test";
}

Singleton* Singleton::getInstance()
{
    if (_instance == nullptr)
        return new Singleton();
    else
        return _instance;
}

void Singleton::getName()
{
    cout << "name" << _name<<endl;
}

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include 
#include "Singleton.h"

int main()
{
    std::cout << "Hello World!\n" << endl;
    
    Singleton::getInstance()->getName();
    
}

懒汉式（线程安全，线程锁）

#pragma once
#include 
#include 
#include 

using namespace std;

class SingletonMutex
{
private:
	SingletonMutex();//私有构造函数
public:
	static SingletonMutex* getInstance();//公开的获取静态实例方法
	static void getName();
private:
	static SingletonMutex* _instance;//私有的唯一的静态实例
	static string _name;
};

#include "SingletonMutex.h"

#include "SingletonMutex.h"

SingletonMutex* SingletonMutex::_instance = nullptr;
string SingletonMutex::_name = "优化后的懒汉式单例";


mutex* m_hCriticalSection; /* 临界区 */


SingletonMutex::SingletonMutex()
{
}

SingletonMutex* SingletonMutex::getInstance()
{
    //双重检查
    if (_instance == nullptr) {
        m_hCriticalSection->lock();
        if (_instance == nullptr)
        {
            _instance = new SingletonMutex();
        }
        m_hCriticalSection->unlock();
    }
     return _instance;
}

void SingletonMutex::getName()
{
    cout << "name:"
        << _name << endl;
}

饿汉式

class HungrySingleton
{
private:
	HungrySingleton();//私有构造函数
public:
	static HungrySingleton* getInstance();//公开的获取静态实例方法
	static void getName();
private:
	static HungrySingleton* _instance;//私有的唯一的静态实例
	static string _name;
};

HungrySingleton* HungrySingleton::_instance = new HungrySingleton();//静态成员需要初始化
string HungrySingleton::_name = "饿汉式单例";

HungrySingleton::HungrySingleton()
{
    _instance = NULL;
}

HungrySingleton* HungrySingleton::getInstance()
{
    return _instance;
}

void HungrySingleton::getName()
{
    cout << "name" << _name << endl;
}

#include 
#include "Singleton.h"



int main()
{
    std::cout << "Hello World!\n" << endl;
    
    LazySingleton::getInstance()->getName();
    HungrySingleton::getInstance()->getName();
    
}