设计模式 - 单例模式

设计模式 - 单列模式

单例模式(Singleton Pattern)

定义: 单例模式(Singleton Pattern)是一种创建型设计模式,确保一个类只有一个实例,并提供一个全局访问点来获取这个实例。该模式通过控制实例的创建过程来避免多次创建同一个对象。

单例模式的关键点:

  1. 只有一个实例:确保某个类在整个系统中只有一个实例。
  2. 全局访问点:提供一个静态方法来访问该实例,确保全局可以访问到这个唯一实例。

单例模式的结构:

  1. 静态实例:类内部有一个静态的实例,只有该类能够访问它。
  2. 私有构造函数:构造函数被声明为私有,避免外部通过构造函数来创建新的实例。
  3. 静态方法:提供一个公共的静态方法(通常称为 getInstance())来获取该实例。

实现方式

1. 懒汉式(Lazy Initialization)

懒汉式单例是在第一次使用时才创建实例,因此延迟了实例的创建,适合实例化过程较为复杂的对象。

复制代码
#include <iostream>

class Singleton {
public:
    // 获取唯一实例
    // 静态成员函数可以在没有实例化对象的时候用类名去调用
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    void showMessage() {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    // 私有构造函数,外部无法直接创建实例
    Singleton() {
        std::cout << "Singleton Instance Created!" << std::endl;
    }

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

    static Singleton* instance;  // 静态实例
};

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

int main() {
    Singleton* singleton1 = Singleton::getInstance();
    singleton1->showMessage();  // 输出: Hello, Singleton!

    Singleton* singleton2 = Singleton::getInstance();
    singleton2->showMessage();  // 输出: Hello, Singleton!

    return 0;
}

说明:

  • instance 是一个静态指针,指向类的唯一实例。
  • 通过 getInstance() 方法来获取实例,在首次访问时创建该实例。
  • 线程不安全:这种方式在多线程环境下可能会导致多个实例的创建。
2. 线程安全的懒汉式(Lazy Initialization, Thread-Safe)

为了避免多线程环境中出现多个实例,通常可以通过加锁来确保线程安全。

复制代码
#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex); // 加锁确保线程安全
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void showMessage() {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    Singleton() {
        std::cout << "Singleton Instance Created!" << std::endl;
    }

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

    static Singleton* instance;
    static std::mutex mutex;  // 用于同步访问
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
    Singleton* singleton1 = Singleton::getInstance();
    singleton1->showMessage();  // 输出: Hello, Singleton!

    Singleton* singleton2 = Singleton::getInstance();
    singleton2->showMessage();  // 输出: Hello, Singleton!

    return 0;
}

说明:

  • 在多线程环境下,std::mutex 用来确保同一时刻只有一个线程可以创建 Singleton 实例。
  • 通过 std::lock_guard<std::mutex> 来管理锁的生命周期。
3. 饿汉式(Eager Initialization)

饿汉式单例模式在类加载时就创建实例,避免了多线程环境中的同步问题。它适用于实例的创建过程简单且不依赖其他资源的场景。

复制代码
#include <iostream>

class Singleton {
public:
    // 获取唯一实例
    static Singleton* getInstance() {
        return &instance;  // 返回静态实例
    }

    void showMessage() {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    // 静态实例,类加载时即创建
    static Singleton instance;

    // 私有构造函数,外部无法直接创建实例
    Singleton() {
        std::cout << "Singleton Instance Created!" << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

// 静态实例初始化(全局对象)
Singleton Singleton::instance;

int main() {
    Singleton* singleton1 = Singleton::getInstance();
    singleton1->showMessage();  // 输出: Hello, Singleton!

    Singleton* singleton2 = Singleton::getInstance();
    singleton2->showMessage();  // 输出: Hello, Singleton!

    return 0;
}

说明:

  • 静态成员 instance 在类加载时就会创建实例,因此无需加锁。
  • 利用静态全局变量,在进入main前就创建示例化
  • 没有延迟加载,适用于那些实例创建过程简单且不依赖其他资源的情况。
4. 懒汉式 + 双重锁机制(Double-Checked Locking)

双重锁机制是一种优化方案,结合了懒汉式和线程安全的特点,只有在首次实例化时加锁,后续访问时无需加锁。

复制代码
#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);  // 加锁
            if (instance == nullptr) {  // 再次检查实例是否为空
                instance = new Singleton();
            }
        }
        return instance;
    }

    void showMessage() {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    Singleton() {
        std::cout << "Singleton Instance Created!" << std::endl;
    }

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

    static Singleton* instance;
    static std::mutex mutex;
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
    Singleton* singleton1 = Singleton::getInstance();
    singleton1->showMessage();  // 输出: Hello, Singleton!

    Singleton* singleton2 = Singleton::getInstance();
    singleton2->showMessage();  // 输出: Hello, Singleton!

    return 0;
}

说明:

  • 只有在示例对象指针为空的时候才去获取锁,并且再次判断,这样再已经实例化后就不用再去互斥,这样在后续减少开销了
  • 双重锁机制减少了在后续获取实例时的加锁开销,仅在实例为空时才加锁。
  • 在多线程环境下,它确保了只有第一个线程会执行实例的创建。

总结:

  • 单例模式确保类只有一个实例,并提供全局访问点。
  • 懒汉式:延迟实例化,适合实例化过程复杂的情况,但多线程环境下需要注意线程安全。
  • 饿汉式:在类加载时即创建实例,简单而线程安全,但不适合资源消耗较大的实例。
  • 双重锁机制:一种线程安全的懒汉式实现,减少了锁的开销。
相关推荐
xiaolang_8616_wjl1 小时前
c++文字游戏_闯关打怪2.0(开源)
开发语言·c++·开源
夜月yeyue1 小时前
设计模式分析
linux·c++·stm32·单片机·嵌入式硬件
收破烂的小熊猫~1 小时前
《Java修仙传:从凡胎到码帝》第四章:设计模式破万法
java·开发语言·设计模式
无小道2 小时前
c++-引用(包括完美转发,移动构造,万能引用)
c语言·开发语言·汇编·c++
FirstFrost --sy4 小时前
数据结构之二叉树
c语言·数据结构·c++·算法·链表·深度优先·广度优先
Tanecious.4 小时前
C++--map和set的使用
开发语言·c++
Yingye Zhu(HPXXZYY)4 小时前
Codeforces 2021 C Those Who Are With Us
数据结构·c++·算法
佛祖让我来巡山4 小时前
【工厂和策略设计模式妙用】解决接口选择与多重if-else 问题
设计模式·策略模式·工厂模式
liulilittle5 小时前
LinkedList 链表数据结构实现 (OPENPPP2)
开发语言·数据结构·c++·链表
无聊的小坏坏6 小时前
三种方法详解最长回文子串问题
c++·算法·回文串