设计模式-单例模式

已于 2024-09-10 09:09:46 修改
阅读量1k 收藏 22
点赞数 36
分类专栏： # 设计模式 文章标签： 设计模式 单例模式
于 2024-08-29 10:14:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wesigj/article/details/141671729
版权

系列文章目录

总目录链接

文章目录

设计模式-单例模式

Overview

单例模式是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

初次接触，直接说懒汉式和饿汉式，容易把人搞懵掉，先认识一下吧！

1.单例模式中懒汉式和饿汉式区别

单例模式中的懒汉式和饿汉式是两种不同的实现策略，它们在实例化单例对象的时机和线程安全性方面有所不同。以下是懒汉式和饿汉式单例模式的主要区别：

1.1.懒汉式（Lazy Initialization）

  1. 实例化时机：懒汉式单例在第一次被使用时才会创建实例，即延迟初始化。

  2. 线程安全性：标准的懒汉式实现不是线程安全的。需要引入锁机制（如双重检查锁定）来保证线程安全。

  3. 资源利用率：由于延迟初始化，懒汉式可能在某些情况下减少资源占用，但这也取决于具体实现和使用场景。

  4. 性能开销：在多线程环境下，可能因为锁机制引入额外的性能开销。

  5. 实现示例：

    class LazySingleton {
private:
    static LazySingleton* instance;
    static std::mutex mutex;

    LazySingleton() {} // 私有构造函数

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

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

1.2.饿汉式（Eager Initialization）

  1. 实例化时机：饿汉式单例在程序启动时就立即创建实例，即立即初始化。

  2. 线程安全性：饿汉式实现是线程安全的，因为它在程序启动时就完成了实例化，不存在多线程竞争的问题。

  3. 资源利用率：饿汉式可能会在程序启动时就占用资源，即使该单例实例尚未被使用。

  4. 性能开销：由于避免了锁机制，饿汉式在单例获取时通常具有较高的性能。

  5. 实现示例：

    class EagerSingleton {
private:
    static EagerSingleton instance; // 静态实例

    EagerSingleton() {} // 私有构造函数

public:
    static EagerSingleton& getInstance() {
        return instance;
    }
};

EagerSingleton EagerSingleton::instance;

1.3.选择建议

  • 如果单例对象的创建成本较高，且在程序早期不需要立即使用，懒汉式可能更合适，因为它可以延迟对象的创建。
  • 如果需要确保线程安全，且对单例对象的创建时机没有特别要求，饿汉式是一个简单且有效的选择。
  • 在多线程环境中，如果使用懒汉式，需要确保通过适当的同步机制（如双重检查锁定）来保证线程安全。

两种实现方式各有优缺点，应根据具体应用场景和需求来选择最合适的实现策略。

2.单例模式 Singleton 实现方式及详细介绍

在 C++中，单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。以下是单例模式的实现方式及详细介绍：

2.1. 懒汉式（线程不安全）

懒汉式单例模式在第一次使用时才会创建实例。

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() {
        // ...
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
  • 在上述代码中， getInstance 函数在第一次被调用时才会创建Singleton类的实例。如果该函数后续被再次调用，将直接返回已经创建的实例。

2.2. 懒汉式（线程安全）

  • 懒汉式单例模式在多线程环境下可能会出现问题。如果多个线程同时进入getInstance函数并且instance为nullptr，那么可能会创建多个实例。
  • 为了解决这个问题，可以使用互斥锁来确保在多线程环境下只有一个线程能够创建实例。例如：
#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() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
    
    // 其他成员函数和数据成员
    void doSomething() {
        // ...
    }
};

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

2.3. 饿汉式（线程安全）

饿汉式单例模式在程序启动时就创建实例。

class Singleton {
private:
    static Singleton instance; // 静态实例

    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        return instance;
    }
    
    // 其他成员函数和数据成员
    void doSomething() {
        // ...
    }
};

// 实现静态成员变量
Singleton Singleton::instance;

2.4. C++11后 局部静态变量（线程安全）

  • 实现原理
    • C++11 引入了线程安全的静态局部变量初始化特性。利用这个特性，可以在获取单例实例的方法中声明一个静态局部变量，该变量在第一次调用方法时被初始化，并且保证线程安全。
    • 利用局部静态变量的线程安全特性实现单例模式。
class Singleton {
private:
    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量
        return instance;
    }
    
    // 其他成员函数和数据成员
    void doSomething() {
        // ...
    }
};

2.5. 注意事项

  • 单例类的构造函数、拷贝构造函数和赋值操作符通常都是私有的，以防止创建多个实例。
  • 需要确保单例的析构函数是公共的，以便能够销毁单例对象。
  • 在多线程环境中，需要特别注意线程安全问题，可以选择使用锁或原子操作来保证线程安全。

单例模式在实际应用中非常广泛，比如配置管理器、数据库连接池管理器等场景。然而，过度使用单例可能导致代码难以测试和维护，因此应谨慎使用。

3.单例模式的应用场景

  • 日志系统
    • 在一个应用程序中，通常只需要一个日志系统来记录各种信息。使用单例模式可以确保无论在程序的哪个部分调用日志系统，都只有一个实例在运行，避免了多个日志系统之间的冲突和资源浪费。
    • 例如，可以将日志系统实现为单例类，提供统一的接口来记录不同级别的日志信息。
  • 数据库连接
    • 在访问数据库时，通常需要建立一个数据库连接。使用单例模式可以确保只有一个数据库连接实例存在，避免了重复建立连接的开销和资源浪费。
    • 例如，可以将数据库连接类实现为单例类，提供方法来执行数据库查询和更新操作。
  • 配置管理
    • 应用程序的配置信息通常在整个程序中都需要访问。使用单例模式可以确保只有一个配置管理实例存在，方便在程序的任何地方获取和修改配置信息。
    • 例如，可以将配置管理类实现为单例类，提供方法来读取和修改配置文件中的参数。

总之，单例模式在 C++ 中是一种非常有用的设计模式，它可以确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。在实际应用中，可以根据具体情况选择懒汉式或饿汉式单例模式，并注意线程安全和资源管理等问题。

4.单例模式在多线程环境下如何保证线程安全？

在多线程环境下保证单例模式的线程安全，可以采用以下几种方法：

4.1. 双重检查锁定（Double-Checked Locking, DCL）

双重检查锁定是一种常见的线程安全单例实现方式，它减少了锁的开销。

#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() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) { // 再次检查实例是否已被创建
                instance = new Singleton();
            }
        }
        return instance;
    }
};

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

4.2. 局部静态变量

利用局部静态变量的线程安全特性，编译器和其他运行时环境保证了局部静态变量的线程安全初始化。

class Singleton {
private:
    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量
        return instance;
    }
};

4.3. 原子操作

使用原子操作来确保实例化过程的原子性，避免多线程同时创建实例。

#include <atomic>
#include <mutex>

class Singleton {
private:
    static std::atomic<bool> initialized;
    static Singleton* instance;
    static std::mutex mutex;

    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        if (!initialized.load()) {
            std::lock_guard<std::mutex> lock(mutex);
            if (!initialized.load()) {
                instance = new Singleton();
                initialized.store(true);
            }
        }
        return instance;
    }
};

// 初始化静态成员变量
std::atomic<bool> Singleton::initialized(false);
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

4.4. 使用 std::call_once 和 std::once_flag

C++11 引入了 std::call_once 函数，它保证在多线程环境下对给定函数的首次调用是单线程执行的。

#include <mutex>

class Singleton {
private:
    static std::mutex mutex;
    static std::once_flag onceFlag;
    static Singleton* instance;

    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        std::call_once(onceFlag, [](){
            instance = new Singleton();
        });
        return instance;
    }
};

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

4.5. 注意事项

  • 双重检查锁定需要使用 std::atomic 或者合适的锁机制来避免多线程环境下的竞态条件。
  • 局部静态变量的方法简单且线程安全，但可能在程序的生命周期内无法释放单例对象占用的资源。
  • std::call_once 是C++11引入的，它提供了一种优雅的方式来保证线程安全的单例模式实现。

在设计单例模式时，需要根据实际的应用场景和需求来选择合适的线程安全实现方式。

5.除了懒汉式和饿汉式，还有哪些实现单例模式的方法？

除了懒汉式和饿汉式，C++中还有其他几种实现单例模式的方法，包括使用C++11标准引入的线程安全静态局部变量、基于函数的局部静态变量、以及使用智能指针。以下是这些方法的示例：

5.1. 线程安全静态局部变量（C++11）

C++11标准规定，静态局部变量在首次使用时会自动初始化，并且是线程安全的。

class Singleton {
private:
    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance; // 线程安全的静态局部变量
        return instance;
    }
    
    // 其他成员函数和数据成员
};

5.2. 基于函数的局部静态变量

在C++中，函数内部的静态变量在首次调用函数时初始化，并且具有线程安全的特性。

class Singleton {
private:
    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton& instance = createInstance();
        return instance;
    }

private:
    static Singleton& createInstance() {
        static Singleton instance;
        return instance;
    }
};

// 其他成员函数和数据成员

5.3. 使用 std::call_once 和 std::once_flag

C++11引入了std::call_once，它用于确保在多线程环境下对某个函数的调用是单次的。

#include <mutex>

class Singleton {
private:
    static std::once_flag onceFlag;
    static Singleton* instance;

    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        std::call_once(onceFlag, [](){
            instance = new Singleton();
        });
        return instance;
    }
    
    // 确保析构函数是公共的，以便能够销毁单例对象
    ~Singleton() {}
};

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

5.4. 使用智能指针

使用std::shared_ptr来管理单例实例，可以自动处理内存释放。

#include <memory>

class Singleton {
private:
    static std::shared_ptr<Singleton> instance;

    Singleton() {} // 私有构造函数

    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static std::shared_ptr<Singleton> getInstance() {
        if (instance == nullptr) {
            instance.reset(new Singleton());
        }
        return instance;
    }
    
    // 其他成员函数和数据成员
};

// 初始化静态成员变量
std::shared_ptr<Singleton> Singleton::instance;

5.5. 注意事项

  • 选择实现单例模式的方法时，需要考虑线程安全性、性能、资源管理等因素。
  • 确保单例的析构函数是公共的，以便能够销毁单例对象。
  • 智能指针方法虽然可以自动管理内存，但在某些情况下可能会引起循环引用或其他问题，需要谨慎使用。

这些方法各有优缺点，可以根据项目的具体需求和约束来选择最合适的实现方式。

关于作者

WeSiGJ
关注
专栏目录
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 956
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
设计模式 - 单例模式
菜鸟小码的博客
08-09 915
单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式对于那些需要频繁创建和销毁对象的场合非常有用，例如日志记录器、缓存管理器、数据库连接池等。本文将详细介绍单例模式的实现原理，并通过具体的Java代码示例来说明如何实现这一模式。
设计模式-单例模式（Singleton Pattern）
weixin_60653563的博客
08-22 1249
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
Python设计模式 - 单例模式
mofei
05-04 977
单例模式是一种创建型设计模式， 其主要目的是确保一个类只有一个实例， 并提供一个全局访问点来访问该实例。
Java创建型设计模式-单例模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1835
好啦，以上就是关于java设计模式的单例模式详细介绍，整理出八种初始化方式及其利弊分析，最佳方式推荐是3.4章节的线程安全单例。
Harmony设计模式-单例模式
不懂先生的博客
06-14 1280
软件设计模式（[Design pattern](https://baike.baidu.com/item/Design pattern/10186718?fromModule=lemma_inlink)），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 731
单例设计模式
【C++】设计模式-单例模式
Jacky_Feng的博客
07-16 1693
单例模式单例模式（Singleton Pattern）是 一种属于创建型设计模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
嵌入式C语言设计模式 --- 单例模式
EmbedIoT Studio
12-29 2268
单例模式（Singleton Pattern）是软件程序设计中最简单的设计模式之一，单例模式在设计模式分类中，是属于创建型模式，它提供了一种创建对象（实例，变量）的最佳实践方式。顾名思义，单例（也叫单件），也就是在整个程序设计中，只存在一个单一的类（C语言中叫“类型”，通常用结构体类型表示），这个类负责创建一个对象（C语言中叫“定义变量”，通常是指结构体变量）
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
常见设计模式-单例模式
10-25
设计模式-单例模式 单例模式是一种常见的设计模式，它的主要作用是确保在内存中仅创建一次对象，并提供一个全局访问点。单例模式有两种类型：饿汉类型和懒汉类型。 饿汉类型的单例模式是在类加载时创建对象，例如...
设计模式、系统设计 record part02
m0_47505062的博客
09-27 1304
软件设计模式1.应对重复发生的问题2.解决方案3.可以反复使用1.本质是面向对象2.优点很多1.创建型-创建和使用分离2.结构型-组合3.行为型-协作5+7+11=23种模式UML-统一建模语言-Unified Modeling Language1.可视化图形化2.各种图（9种图）3.可以同时表示静态信息、动态信息类图就是图形化显式类关联关系。
行为设计模式 -模板方法模式- JAVA
智的博客
09-28 1764
模板方法是一种行为设计模式。模板方法设计模式用于创建方法存根并将某些实现步骤推迟到子类。模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构**的情况下，重新定义算法中的某些步骤。在面向对象程序设计过程中，我们常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。通俗理解，就是设计构建一个对象的时候，类的步骤已经固定了，可是某些类的实现逻辑。
【Java】六大设计原则和23种设计模式
weixin_71491685的博客
09-28 1345
代理模式给某一个对象提供一个代理对象并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。
设计模式之访问者模式
一个老Java开发的自白
10-02 1051
访问者模式是一种强大的设计模式，它通过将数据结构与数据操作分离，使得系统更加灵活和可扩展。然而，它也有一些缺点，如增加新的数据结构困难、破坏封装等。因此，在使用访问者模式时，需要权衡其优缺点，并根据具体的应用场景进行选择。 在实际开发中，访问者模式通常适用于需要对一个对象结构中的对象进行很多不同并且不相关的操作的场景。在这些情况下，使用访问者模式可以避免让这些操作“污染”这些对象的类，从而保持代码的清晰和简洁。
设计模式-适配器模式
最新发布
ZSS1753936255的博客
10-02 243
这段代码就是在适配器Adapter中关联了适配器适配器母接口Speker. 在适配器中的translate中实现了 speaker.speak()方法。首先：如何调用被适配的对象呢？可以通过 关联或者继承 适配器来实现。（1：这段代码是通过是通过继承来实现的，也达到了接口转换的目的）适配器模式：将一类的接口转换成满足用户需求的另一种接口。是的不相容的接口得以共同工作。2:通过对象关联的方法来实现适配器，就是上述的UML类图保持一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WeSiGJ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值