设计模式之单例模式(C++实现)

更多设计模式参看： 设计模式之模式概述(模式汇总)(C++实现)

介绍

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

意图：

单例模式(Singleton Pattern)： 确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

解决问题：

一个全局使用的类频繁地创建与销毁。

实现概述：

构造函数是私有的，避免外部通过 new 创建实例。 getInstance() 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

要点：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例

应用场景：

(1) 系统只需要一个实例对象，比如，配置信息类，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

生活中场景

Windows任务管理器只能启动一个

软件中场景

负载均衡器，配置信息类等

优点：

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

缺点：

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

模式结构

角色

单例模式是结构最简单的设计模式一，在它的核心结构中只包含一个被称为单例类的特殊类。（下图为单例模式懒汉式结构图）

类图

代码示例

饿汉式

只有在第一次用到类实例的时候才实例化。不过，这样的实现方式不支持延迟加载。

由于是一个static对象，可以保证对象只生成一次，线程安全的。

GitHub

EagerSingleton

饿汉式单例类

class EagerSingleton {
public:

    static EagerSingleton *getInstance(){
        return instance;
    }
    static void delInstance() {
        if(instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }
private:
    EagerSingleton(){
        std::cout << "EagerSingleton Hello" << std::endl;
    };
    ~EagerSingleton() { // 私有化 可以避免 直接 delete s1 ，必须 使用 delInstance
        std::cout << "EagerSingleton Bye" << std::endl;
    }
    // static对象，可以保证对象只生成一次,并且是多线程安全
    static EagerSingleton *instance;
};
// 饿汉模式的关键：初始化即实例化
EagerSingleton *EagerSingleton::instance = new EagerSingleton();

测试

int main() {
    EagerSingleton *s1 = EagerSingleton::getInstance();
    EagerSingleton *s2 = EagerSingleton::getInstance();

    std::cout << "s1 address = " << s1 << std::endl;
    std::cout << "s2 address = " << s2 << std::endl;

    EagerSingleton::delInstance();

    getchar();
    return 0;
}

输出

懒汉式

懒汉式单例在第一次调用getInstance()方法时实例化，在类加载时并不自行实例化，这种技术又称为**延迟加载*(Lazy Load)***技术，即需要的时候再加载实例，为了避免多个线程同时调用getInstance()方法，我们可以使用锁或者static变量

GitHub

懒汉式单例类+双检查锁: LazySingleton01

懒汉式单例类+static变量: LazySingleton02

懒汉式单例类+双检查锁

class LazySingleton {
public:
    static LazySingleton *getInstance() {
        //第一个检查，如果只是读操作，就不许用加锁
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lck(m_mutex);
            //第二个检查，保证只有一个
            if (instance == nullptr) {
                instance = new LazySingleton;
            }
        }
        return instance;
    }
    static void delInstance() {
        if(instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }
private:
    LazySingleton(){
        std::cout << "LazySingleton Hello" << std::endl;
    };
    ~LazySingleton() { // 私有化 可以避免 直接 delete s1 ，必须 使用 delInstance
        std::cout << "LazySingleton Bye" << std::endl;
    }
    
    static LazySingleton *instance;
    static std::mutex m_mutex;
};

LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::m_mutex;

懒汉式单例类+static变量

class LazySingleton {
public:
    static LazySingleton *getInstance() {
        static LazySingleton instance;
        return &instance;
    }

private:
    LazySingleton(){
        std::cout << "LazySingleton Hello" << std::endl;
    };
    ~LazySingleton() { // 私有化 可以避免 直接 delete s1 ，必须 使用 delInstance
        std::cout << "LazySingleton Bye" << std::endl;
    }
};

1、C++11中可以保证static变量时多线程安全的，在底层实现了加锁操作，所以不需要像以前那样自己写加锁操作。

2、由于是一个static对象，可以保证对象只生成一次；

3、在程序结束的时候，系统会调用对应的析构函数；如果是new出来的对象，程序结束的时候，系统不会自动调用析构函数。

测试

懒汉式单例类+双检查锁

int main() {
    LazySingleton *s1 = LazySingleton::getInstance();
    LazySingleton *s2 = LazySingleton::getInstance();

    std::cout << "s1 address = " << s1 << std::endl;
    std::cout << "s2 address = " << s2 << std::endl;

    LazySingleton::delInstance();

    getchar();
    return 0;
}

懒汉式单例类+static变量

int main() {
    LazySingleton *s1 = LazySingleton::getInstance();
    LazySingleton *s2 = LazySingleton::getInstance();

    std::cout << "s1 address = " << s1 << std::endl;
    std::cout << "s2 address = " << s2 << std::endl;
    

    getchar();
    return 0;
}

输出

懒汉式单例类+双检查锁

懒汉式单例类+static变量

个人能力有限，如有错误之处或者其他建议，敬请告知欢迎探讨，谢谢!