设计模式之单例模式

已于 2024-06-06 11:53:39 修改
阅读量1k 收藏 20
点赞数 33
分类专栏： 设计模式 文章标签： 设计模式 单例模式
于 2024-06-06 11:51:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38492525/article/details/139496350
版权

单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单例模式主要用于需要控制资源的访问和共享，比如日志记录、数据库连接、线程池等。

组成部分

单例模式的核心在于如何确保一个类只有一个实例，并提供一个全局访问点。以下是单例模式的主要组成部分：

  1. 私有的构造函数：防止外部创建该类的实例。
  2. 一个静态的私有类实例：持有该类的唯一实例。
  3. 一个公有的静态方法：用于返回该类的唯一实例。

UML类图

+-------------------+
|     Singleton     |
+-------------------+
| -instance: Singleton |
+-------------------+
| +getInstance()    |
| +someBusinessLogic()|
+-------------------+

C++ 示例代码

以下是一个实现单例模式的C++示例：

#include <iostream>
#include <mutex>

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

    // 私有构造函数防止外部实例化
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 防止拷贝构造和赋值操作
    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 someBusinessLogic() {
        std::cout << "Executing some business logic." << std::endl;
    }
};

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

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

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

    if (s1 == s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    return 0;
}

代码解释

  1. 私有构造函数：Singleton 类的构造函数是私有的，防止外部实例化。
  2. 静态实例：静态指针 instance 持有 Singleton 类的唯一实例。
  3. 静态方法 getInstance：该方法通过检查 instance 是否为空来决定是否创建新的实例，并使用互斥锁 mutex 确保线程安全。
  4. 防止拷贝和赋值：通过删除拷贝构造函数和赋值运算符，防止生成多个实例。

优点

  1. 控制实例数量：确保一个类只有一个实例，节省资源。
  2. 全局访问：提供全局访问点，方便获取实例。
  3. 延迟实例化：实例在第一次使用时才创建，实现了延迟加载。

缺点

  1. 全局状态：由于单例模式提供了全局访问点，可能导致隐藏的依赖关系和全局状态，影响程序可测试性。
  2. 线程安全：在多线程环境下实现单例模式需要注意线程安全问题，增加了实现的复杂性。
  3. 垃圾回收：在某些语言（如C++）中，单例对象可能在程序结束时无法正确释放，导致资源泄露。(下面会详细解释)

改进建议

在实际使用中，可以根据具体情况选择合适的单例实现方式，比如：

  • 懒汉模式（Lazy Initialization）：实例在第一次使用时创建，适用于初始化开销较大的情况。
  • 饿汉模式（Eager Initialization）：实例在程序启动时创建，适用于初始化开销较小且需尽早使用的情况。
  • 双重检查锁（Double-checked Locking）：在多线程环境下减少锁开销，提升性能。

变体实现

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

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

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

    void someBusinessLogic() {
        std::cout << "Executing some business logic." << std::endl;
    }
};

int main() {
    Singleton& s1 = Singleton::getInstance();
    s1.someBusinessLogic();

    Singleton& s2 = Singleton::getInstance();
    s2.someBusinessLogic();

    if (&s1 == &s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    return 0;
}

在这种实现中，使用了C++11引入的局部静态变量特性，确保 Singleton 实例在第一次调用 getInstance 方法时被创建，并且该实例在程序结束时自动销毁。这种方式简化了实现，并且天然线程安全（在C++11之后局部静态变量的初始化是天然安全的，所以尽管多个线程同时访问getInstance也不会发生线程的竞争）。

关于上面提到的三个缺点的解释

1. 全局状态

问题：由于单例模式提供了一个全局访问点，这使得它类似于全局变量。全局状态带来了以下问题：

  • 隐藏依赖：当类依赖于一个单例对象时，这种依赖关系可能并不明显，容易导致代码难以理解和维护。
  • 难以追踪：全局状态可能会在程序的任何地方被修改，使得追踪状态变化变得困难。
  • 难以测试：全局状态使得单元测试变得复杂，因为测试需要处理或模拟全局状态，这可能导致测试相互影响，无法并行执行。

示例：
假设一个程序使用了一个单例配置管理器，如果这个配置管理器的状态被一个模块修改，另一个模块使用时的行为可能会不可预测。

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

    void setValue(const std::string& key, const std::string& value) {
        config[key] = value;
    }

    std::string getValue(const std::string& key) {
        return config[key];
    }

private:
    std::map<std::string, std::string> config;
    ConfigurationManager() = default;
};

在测试中，如果不同测试用例依赖于配置管理器的不同状态，会导致测试间相互影响，难以保证测试的独立性和可靠性。

2. 线程安全

问题：在多线程环境中实现单例模式时，需要确保线程安全性。这通常会增加实现的复杂性，如果处理不当，可能会导致竞争条件、死锁等问题。

  • 竞争条件：多个线程同时访问和修改单例实例时，可能会导致竞争条件，导致不一致的状态或崩溃。
  • 死锁：不正确的锁机制可能会导致死锁，使程序无法继续运行。

解决方案：常见的线程安全实现包括使用互斥锁（mutex）保护实例创建过程，或使用双重检查锁（double-checked locking）机制。

示例：

#include <mutex>

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

private:
    Singleton() = default;
    static Singleton* instance;
    static std::mutex mutex;
};

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

尽管这种方法解决了线程安全问题，但引入了锁机制，可能会影响性能。

3. 垃圾回收

问题：在某些编程语言（如C++）中，单例对象可能无法在程序结束时正确释放，导致资源泄漏。尽管许多现代语言和编译器能够在程序结束时自动释放内存，但在某些情况下，资源（如文件句柄、网络连接等）仍需要显式释放。

  • 资源泄漏：如果单例对象持有昂贵的资源而没有正确释放，这些资源可能在程序的生命周期中一直占用，导致内存泄漏或资源枯竭。
  • 程序退出时序：单例对象的销毁顺序在某些复杂情况下可能会引发问题，特别是在有全局对象的情况下。

解决方案：可以使用智能指针管理单例对象的生命周期，或在程序结束时显式释放单例对象。

示例：

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

    ~Singleton() {
        // 清理资源
    }

private:
    Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

在这种实现中，使用了C++11的局部静态变量特性，确保单例对象在程序结束时自动销毁。这种方法简化了资源管理，但在某些情况下，可能需要更显式的资源清理方式。

总结

单例模式的三个主要缺点（全局状态、线程安全、垃圾回收）都可能对程序的可维护性、性能和资源管理产生影响。在使用单例模式时，需要权衡其优缺点，并根据具体需求选择合适的实现方式和补救措施。

如果一定要使用指针的形式那么提供以下三种方法来避免内存泄漏

在使用指针实现单例模式时，需要考虑在适当的时间释放单例对象，以避免资源泄漏。通常有几种方法来管理单例对象的生命周期：

1. 程序结束时自动释放

使用静态指针和智能指针，可以在程序结束时自动释放单例对象。常用的方法是使用 std::unique_ptr 或 std::shared_ptr 管理单例对象。

示例：使用 std::unique_ptr

#include <iostream>
#include <memory>
#include <mutex>

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

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

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

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

    void someBusinessLogic() {
        std::cout << "Executing some business logic." << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }
};

// 初始化静态成员
std::unique_ptr<Singleton> Singleton::instance = nullptr;
std::mutex Singleton::mutex;
int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->someBusinessLogic();

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

    if (s1 == s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    return 0;
}

在这种方法中，std::unique_ptr 会在程序结束时自动释放单例对象，确保资源正确释放。

2. 使用 atexit 函数

可以注册一个清理函数，在程序结束时调用它来释放单例对象。

示例：使用 atexit 函数

#include <iostream>
#include <cstdlib>

class Singleton {
private:
    static Singleton* instance;

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

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

    static void destroyInstance() {
        delete instance;
        instance = nullptr;
    }

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

    void someBusinessLogic() {
        std::cout << "Executing some business logic." << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }
};

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

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

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

    if (s1 == s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    return 0;
}

在这种方法中，destroyInstance 函数会在程序结束时自动调用，确保单例对象正确释放。

3. 显式调用析构函数

在某些情况下，可能需要在特定时刻显式地释放单例对象。这可以通过显式调用一个清理函数来实现。

示例：显式调用析构函数

#include <iostream>

class Singleton {
private:
    static Singleton* instance;

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

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

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

    static void destroyInstance() {
        delete instance;
        instance = nullptr;
    }

    void someBusinessLogic() {
        std::cout << "Executing some business logic." << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }
};

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

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

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

    if (s1 == s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    // 显式释放单例对象
    Singleton::destroyInstance();

    return 0;
}

在这种方法中，用户需要在适当的时机显式调用 destroyInstance 来释放单例对象。

结论

根据具体需求，可以选择上述任何一种方法来管理单例对象的生命周期。推荐使用 std::unique_ptr 或 std::shared_ptr 这种现代C++特性来自动管理资源，简化代码并避免内存泄漏。如果需要更精细的控制，可以选择显式调用析构函数或使用 atexit 注册清理函数。

Grazve
关注
  • 33
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
java设计模式之单例模式
08-29
java设计模式之单例模式 单例模式是java设计模式中的一种常用的创建型模式，是我们日常开发中最常使用的一种设计模式。它的主要作用是保证系统中一个类只有一个实例。单例模式可以被用来封装一些工具类，例如数据库...
研磨设计模式之单例模式
02-27
 单例模式（Singleton）1 场景问题1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的...
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
常用设计模式
u010992421的专栏
07-12 938
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 496
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 601
Java设计模式设计原则
JavaScript设计模式 -- 代理模式
m0_73280507的博客
07-10 975
@FilePath: \设计模式\代理模式.md* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE。
设计模式探索：适配器模式
搬砖的小熊猫的博客
07-09 1167
将一个类的接口转换为客户期望的另一个接口，适配器可以让不兼容的两个类一起协同工作。适配器模式的主要作用是把原本不兼容的接口，通过适配修改做到统一，使得用户方便使用。比如，万能充电器和多接口数据线都是为了适配各种不同的接口。为什么要转换接口？原接口和目标接口都已经存在，不易修改接口代码。抽象接口希望复用已有组件的逻辑。优点：解耦合: 适配器模式允许两个没有直接关联的类协同工作，降低了它们之间的耦合度。提高复用性: 通过适配器，可以重用现有的类，而不需要修改它们的代码。统一接口。
java设计模式之:策略模式+工厂模式整合案例实战(一)
royal1235的博客
07-12 300
然后通过策略工厂来获取具体的策略类：(由于只有三个策略类，所以通过注入的方式对channel进行判断)案例1：项目中对系统中的客户和销售进行事件通知(短信、邮件、钉钉)到此该版本的策略模式+工厂模式就结束了，欢迎点评和指出不足之处。首先要有通知的策略接口，接口里面要有一个方法就是通知的方法。有了接口那必然有实现类，三个实现类短信、邮件、钉钉。该案例是针对策略类比较少的情况。下一篇会讲解策略类比较多的案例。本文介绍项目中常用的。
Java面试题系列 - 第9天
一杯梅子酱的博客
07-11 884
它们是前辈开发者在实践中总结出来的经验教训，通过模式化的设计，可以减少代码的复杂性，提高代码的复用性和可维护性。设计模式的重要性在于，它们提供了一种通用的语言，使得开发者能够更有效地沟通和协作。：观察者模式 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。：设计模式是软件工程中解决问题的常见方案，它们提供了经过验证的模板，帮助开发者解决在软件设计过程中遇到的特定问题。设计模式的学习是一个持续的过程，随着经验的积累，开发者会更加熟练地应用这些模式来解决复杂的设计问题。
Java中的设计模式：工厂模式
技术研究中心
07-10 258
本文介绍了工厂模式及其在Java中的三种主要形式：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其独特的应用场景和实现方式，可以帮助开发人员更好地管理对象的创建过程，提高代码的可扩展性和可维护性。简单工厂模式是工厂模式的最简单形式，它通过一个共同的接口或父类来创建对象，但客户端不需要知道具体实现类。抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！
设计模式03-组合模式
TonyWu的博客
07-10 546
组合模式又称为“部分-整体”模式，它将对象组合成树形结构以表示“整体-部分”的层次结构。组合模式让客户端能够忽略单个对象和组合对象的差异，以统一的方式处理它们。组合对象：包含一个或多个叶子对象，同时也可以包含其他组合对象，形成一个树形结构。叶子对象：最基本的对象，不包含其他对象。组合模式是一种强大的设计模式，它允许以一致的方式处理单个对象和对象组合，从而简化了客户端代码，提高了系统的可扩展性和灵活性。然而，在使用组合模式时，也需要注意其可能带来的设计抽象化、性能问题和复杂性增加等缺点。
设计模式使用场景实现示例及优缺点（结构型模式——组合模式）
懒人w的博客
07-12 639
组合模式提供了一种灵活的结构，用于表示具有层次结构的对象。它使得客户端可以统一地处理单个对象和组合对象，简化了客户端代码的复杂性。这种模式特别适合那些需要处理对象集合的场景，例如图形用户界面组件、文件系统等。
设计模式使用场景实现示例及优缺点（行为型模式——模板方法模式）
最新发布
懒人w的博客
07-13 278
模板方法模式（Template Method Pattern）是一种行为设计模式，它定义了一个操作中的算法的骨架，将算法的一些步骤延迟到子类中。这样可以在不改变算法的结构的前提下，重新定义算法的某些特定步骤。
设计模式：建造者模式
weixin_44318762的博客
07-10 845
建造者模式是一种将复杂对象的构建与其表示分离的设计模式。通过使用不同的建造者，可以创建具有不同表示的对象。它主要用于创建一些复杂对象，这些对象由多个部分组成，而这多个部分通常需要分步骤创建。产品（Product）需要构建的复杂对象。建造者（Builder）构建产品的各个部分的抽象接口。具体建造者（ConcreteBuilder）实现Builder接口，构建和装配各个部件。指挥者（Director）构建一个使用Builder接口的对象。
Java学习高级三
weixin_45730243的博客
07-12 328
【代码】Java学习高级三。
设计模式之外观模式（Facade）
07-09 641
Facade设计模式，也称为外观模式，是一种结构型设计模式，它主要用于为子系统中的一组接口提供一个统一的高层接口，从而使得子系统更加容易使用。
设计模式之组合模式
07-12 778
设计模式之组合模式（Composite Pattern），又称为“整体—部分”（Part-Whole）模式，是一种结构型设计模式。它通过将一组相似的对象组合成树形结构来表示“部分-整体”的层次关系，使得用户对单个对象和组合对象的使用具有一致性。
php语言设计模式之单例模式educoder
03-16
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在PHP中，可以通过定义一个私有的构造函数和一个静态的getInstance方法来实现单例模式。在getInstance方法中，如果类的实例不存在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值