04_23 种设计模式之《单例模式》

文章目录

• • 一、单例模式基础知识
  • • [单例模式有 3 个特点：](#单例模式有 3 个特点：)
  • [单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式通常用于管理共享资源，如数据库连接、配置文件、日志记录等。](#单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式通常用于管理共享资源，如数据库连接、配置文件、日志记录等。)
  • • 单例模式的结构
  • C++实现单例模式
  • • 线程安全的单例模式
    • 单例模式的应用场景
    • 注意事项
  • 懒汉模式和饿汉模式是单例模式的两种实现方式，它们在创建单例对象的时机上有所不同。
  • • [饿汉模式（Eager Initialization）](#饿汉模式（Eager Initialization）)
    • [懒汉模式（Lazy Initialization）](#懒汉模式（Lazy Initialization）)
    • • 测试

一、单例模式基础知识

单例模式的定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

单例模式有 3 个特点：

单例类只有一个实例对象；

单例类必须自己创建自己的唯一实例；

单例类对外提供一个访问该单例的全局访问点。

主要解决：全局使用的类频繁地创建与销毁。

优点：避免对资源的多重占用。在内存里只有一个实例，减少内存的开销，尤其是频繁的创建和销毁实例。

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这种模式通常用于管理共享资源，如数据库连接、配置文件、日志记录等。

单例模式的结构

单例模式通常包含以下元素：

1. 单例类（Singleton）：包含一个实例化的自身引用，以及一个静态私有方法来获取这个实例。
2. 客户端：通过单例类提供的静态方法获取单例对象的引用。

C++实现单例模式

在C++中实现单例模式需要考虑线程安全性和延迟初始化的问题。

#include <iostream>

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数

    // 禁止拷贝和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();

    Singleton* s2 = Singleton::getInstance();
    s2->doSomething();

    // s1 和 s2 是同一个实例
    return 0;
}

线程安全的单例模式

在多线程环境中，需要确保只有一个线程可以创建单例实例。以下是一个线程安全的单例模式实现：

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;
    Singleton() {} // 私有构造函数

    // 禁止拷贝和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();

    Singleton* s2 = Singleton::getInstance();
    s2->doSomething();

    // s1 和 s2 是同一个实例
    return 0;
}

单例模式的应用场景

1. 日志记录：整个应用程序可能需要一个共享的日志记录器。
2. 配置管理：应用程序可能需要读取一次配置信息，并在整个应用程序中使用。
3. 网络连接：创建一个全局的网络连接管理器，用于管理所有的网络请求。
4. 线程池：一个应用程序可能只需要一个线程池实例来管理所有的后台任务。

注意事项

• 全局状态：过度使用单例模式可能导致全局状态管理困难，难以测试和维护。
• 延迟初始化：在某些情况下，可能希望延迟单例实例的创建，直到实际需要时才初始化。
• 销毁问题：需要确保单例实例在应用程序结束时能够正确销毁，避免内存泄漏。

懒汉模式和饿汉模式是单例模式的两种实现方式，它们在创建单例对象的时机上有所不同。

饿汉模式（Eager Initialization）

饿汉模式在类加载时就立即初始化，创建单例对象。这种方式的缺点是不管是否使用这个单例，都会创建实例，可能导致资源浪费。

特点：

1. 类加载时就立即初始化，创建单例对象。
2. 不需要加锁同步，实例的创建线程安全。
3. 实例的创建时机早，可能会造成资源浪费。

实现示例：

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* getInstance() {
        return instance;
    }

    // 其他成员函数...
};

// 在类外部初始化静态成员变量
Singleton* Singleton::instance = new Singleton();

懒汉模式（Lazy Initialization）

懒汉模式在第一次使用单例对象时才创建实例，这样可以延迟对象的创建，节省资源。但是，它需要处理多线程环境下的线程安全问题。

特点：

1. 按需创建，只有在真正需要的时候才创建实例。
2. 需要加锁同步，确保线程安全。
3. 实例的创建时机晚，节省资源，但可能影响性能。

实现示例：

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;
    Singleton() {}

public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 其他成员函数...
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

在实际应用中，选择哪种模式取决于具体的需求和场景。如果单例的实例化代价较大，且不太可能造成资源浪费，可以选择饿汉模式。如果需要更灵活地控制实例的创建时机，或者实例化代价较小，可以选择懒汉模式。

测试

void TestFunction1() {
	Singleton* pobj1 = Singleton::GetInstance();
	Singleton* pobj2 = Singleton::GetInstance();

	if (pobj1 == pobj2)
	{
		cout << "pobj1和pobj2两个指针指向同一块内存单元：则为单例模式." << endl;
	}
	else
	{
		cout << "pobj1和pobj2两个指针指向不是同一块内存单元：不是单例模式." << endl;
	}
}