单例模式

单例模式

• 单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一实例
4. 构造函数私有防止被其他类创建

优点

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

缺点

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

使用场景

1. 要求生产唯一序列号
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等

分类

• 懒汉式：类初始化延迟到第一次获取实例，延迟加载，减少可能不需要的资源消耗
• 饿汉式：程序初始化即初始化好实例，获取实例加快，占用固定资源

示例

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

// 懒汉式（线程安全）
class LazyManager
{
public:
    static LazyManager* getInstance()
    {
        if (nullptr == _pDisplayManager)
        {
            _initLock.lock();
            {
                if (nullptr == _pDisplayManager)
                {
                    _pDisplayManager = new LazyManager();
                }
            }
            _initLock.unlock();
        }

        return _pDisplayManager;
    }

    void SayHi()
    {
        std::cout << "I am lazy" << std::endl;
    }

private:
    // 构造函数私有
    LazyManager()
    {
        std::cout << "Lazy Manager Construct" << std::endl;
    };

    static bool _hasInited;
    static std::mutex _initLock;
    static LazyManager* _pDisplayManager;
};

LazyManager* LazyManager::_pDisplayManager = nullptr;
std::mutex LazyManager::_initLock;
bool LazyManager::_hasInited = false;

// 饿汉式（线程安全）
class HungryManager
{
public:
    static HungryManager* getInstance()
    {
        return _hungryManager;
    }

    void SayHi()
    {
        std::cout << "I am hungry" << std::endl;
    }
private:
    // 构造函数私有
    HungryManager()
    {
        std::cout << "Lazy Manager Construct" << std::endl;
    }
    static HungryManager* _hungryManager;
};

HungryManager* HungryManager::_hungryManager = new HungryManager();


// 调用示例
int main()
{
    LazyManager* lazyManager = LazyManager::getInstance();
    LazyManager* lazyManager2 = LazyManager::getInstance();
    lazyManager->SayHi();
    lazyManager2->SayHi();

    HungryManager* hungryManager = HungryManager::getInstance();
    HungryManager* hungryManager2 = HungryManager::getInstance();
    hungryManager->SayHi();
    hungryManager2->SayHi();
}

>>>
Lazy Manager Construct
Lazy Manager Construct
I am lazy
I am lazy
I am hungry
I am hungry