创建型设计模式之单例模式

于 2025-05-21 08:00:00 发布
阅读量778 收藏 23
点赞数 17
分类专栏： # 创建型设计模式 架构设计模式 C# 文章标签： 设计模式 单例模式 微软 windows c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/O_____V_____O/article/details/148040862
版权
#新星杯·14天创作挑战营·第11期#

文章目录

引言

在软件开发中，有时我们需要确保某个类在整个应用程序中只有一个实例。例如，数据库连接管理器、日志记录器或配置管理器等。这些组件通常需要在应用程序的不同部分共享相同的状态或者资源，如果每次需要时都创建新的实例，可能导致资源浪费或者状态不一致的问题。为了解决这类问题，我们可以使用单例设计模式。

单例模式是创建型设计模式之一，它属于GoF（Gang of Four，四人帮）提出的23种设计模式中的一种。本文将详细介绍单例模式的概念、实现方式、应用场景以及优缺点，并通过详细的C#代码示例来展示其实现。

单例模式定义

单例模式（Singleton Pattern）的定义是：确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

单例模式主要解决的问题包括：

  • 确保一个类只有一个实例
  • 为该实例提供一个全局访问点
  • 控制共享资源的并发访问

单例模式的UML类图

以下是单例模式的UML类图：
Singleton
static Singleton instance
Singleton()
static Singleton GetInstance()
BusinessLogic()

在这个UML图中：

  • Singleton类有一个私有的静态实例变量instance
  • 构造函数Singleton()是私有的，防止外部直接创建对象
  • 提供了一个公共的静态方法GetInstance()用于获取单例实例
  • BusinessLogic()代表单例类的业务方法

单例模式的实现方式

在C#中，实现单例模式有多种方式，下面将介绍最常见的几种实现方法。

1. 懒汉式（延迟加载）

懒汉式单例是最基本的单例实现，它在第一次被调用时才创建实例，这就是所谓的延迟加载（Lazy Loading）。

/// <summary>
/// 懒汉式单例模式（非线程安全）
/// </summary>
public class LazySingleton
{
    // 私有静态变量，用于保存单例实例
    private static LazySingleton instance;
    
    // 私有构造函数，防止外部直接创建实例
    private LazySingleton()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("LazySingleton实例被创建");
    }
    
    // 公共静态方法，提供全局访问点
    public static LazySingleton GetInstance()
    {
        // 如果实例尚未创建，则创建实例
        if (instance == null)
        {
            instance = new LazySingleton();
        }
        
        // 返回单例实例
        return instance;
    }
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用懒汉式单例模式");
    }
}

特点：

  • 延迟加载，第一次使用时才创建实例
  • 非线程安全，多线程环境下可能创建多个实例
  • 实现简单直观

2. 饿汉式（预先加载）

饿汉式单例在类加载时就创建实例，而不管是否会被使用到，这就是所谓的预先加载（Eager Loading）。

/// <summary>
/// 饿汉式单例模式（线程安全）
/// </summary>
public class EagerSingleton
{
    // 在静态字段初始化时就创建实例
    private static readonly EagerSingleton instance = new EagerSingleton();
    
    // 私有构造函数，防止外部直接创建实例
    private EagerSingleton()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("EagerSingleton实例被创建");
    }
    
    // 公共静态方法，提供全局访问点
    public static EagerSingleton GetInstance()
    {
        // 直接返回已创建的实例
        return instance;
    }
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用饿汉式单例模式");
    }
}

特点：

  • 在类加载时就创建实例，不管是否会被使用
  • 天然线程安全，不会出现多个实例
  • 如果初始化过程耗时长或占用较多资源，可能造成资源浪费

3. 线程安全的实现方式

为了解决懒汉式单例在多线程环境下的问题，可以使用锁机制来确保线程安全。

/// <summary>
/// 线程安全的懒汉式单例模式
/// </summary>
public class ThreadSafeSingleton
{
    // 私有静态变量，用于保存单例实例
    private static ThreadSafeSingleton instance;
    
    // 定义一个对象作为锁
    private static readonly object lockObject = new object();
    
    // 私有构造函数，防止外部直接创建实例
    private ThreadSafeSingleton()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("ThreadSafeSingleton实例被创建");
    }
    
    // 线程安全的公共静态方法，提供全局访问点
    public static ThreadSafeSingleton GetInstance()
    {
        // 锁定共享资源，确保只有一个线程可以执行实例化逻辑
        lock (lockObject)
        {
            // 如果实例尚未创建，则创建实例
            if (instance == null)
            {
                instance = new ThreadSafeSingleton();
            }
        }
        
        // 返回单例实例
        return instance;
    }
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用线程安全的单例模式");
    }
}

特点：

  • 线程安全，保证只创建一个实例
  • 延迟加载，第一次使用时才创建实例
  • 每次调用GetInstance()方法都会锁定，可能影响性能

4. 双重检查锁定

双重检查锁定（Double-Check Locking）是对线程安全单例模式的一种优化，它减少了锁定的次数，提高了性能。

/// <summary>
/// 使用双重检查锁定的单例模式
/// </summary>
public class DoubleCheckSingleton
{
    // 使用volatile关键字确保多线程环境下变量的可见性
    private static volatile DoubleCheckSingleton instance;
    
    // 定义一个对象作为锁
    private static readonly object lockObject = new object();
    
    // 私有构造函数，防止外部直接创建实例
    private DoubleCheckSingleton()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("DoubleCheckSingleton实例被创建");
    }
    
    // 使用双重检查锁定的公共静态方法，提供全局访问点
    public static DoubleCheckSingleton GetInstance()
    {
        // 第一次检查，如果实例已经创建，直接返回，不需要锁定
        if (instance == null)
        {
            // 只有当实例为null时才锁定对象
            lock (lockObject)
            {
                // 第二次检查，防止多个线程同时通过第一次检查
                if (instance == null)
                {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        
        // 返回单例实例
        return instance;
    }
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用双重检查锁定的单例模式");
    }
}

特点：

  • 线程安全，保证只创建一个实例
  • 延迟加载，第一次使用时才创建实例
  • 相比普通的线程安全实现，减少了锁定次数，提高了性能
  • 使用volatile关键字保证多线程环境下变量的可见性

5. 静态内部类

静态内部类实现单例利用了C#中的类加载机制，是一种既线程安全又能延迟加载的实现方式。

/// <summary>
/// 使用静态内部类实现的单例模式
/// </summary>
public class StaticNestedSingleton
{
    // 私有构造函数，防止外部直接创建实例
    private StaticNestedSingleton()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("StaticNestedSingleton实例被创建");
    }
    
    // 私有静态内部类，用于保存单例实例
    private static class SingletonHolder
    {
        // 在静态内部类中初始化单例实例
        // 这个过程只会在GetInstance()第一次被调用时发生
        public static readonly StaticNestedSingleton INSTANCE = new StaticNestedSingleton();
    }
    
    // 公共静态方法，提供全局访问点
    public static StaticNestedSingleton GetInstance()
    {
        // 返回静态内部类中的实例
        return SingletonHolder.INSTANCE;
    }
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用静态内部类的单例模式");
    }
}

特点：

  • 线程安全，保证只创建一个实例
  • 利用类加载机制实现延迟加载
  • 实现简洁，不需要使用锁或者volatile关键字
  • 适用于绝大多数单例场景

6. C# 6.0后的更简单实现

在C# 6.0及以后的版本中，可以使用自动属性初始化器和表达式体成员，实现更简洁的单例模式。

/// <summary>
/// C# 6.0及之后版本的简化单例实现
/// </summary>
public class ModernSingleton
{
    // 私有构造函数，防止外部直接创建实例
    private ModernSingleton() { }
    
    // 使用静态属性初始化器和表达式体成员
    public static ModernSingleton Instance { get; } = new ModernSingleton();
    
    // 使用表达式体成员定义业务方法
    public void ShowMessage() => Console.WriteLine("使用C# 6.0后的简化单例实现");
}

特点：

  • 代码简洁明了
  • 在类加载时就创建实例（饿汉式）
  • 线程安全
  • 需要C# 6.0或更高版本

还可以结合Lazy类，实现既线程安全又能延迟加载的现代单例：

/// <summary>
/// 使用Lazy<T>实现的单例模式
/// </summary>
public class LazySingletonModern
{
    // 使用Lazy<T>实现延迟加载，并保证线程安全
    private static readonly Lazy<LazySingletonModern> lazyInstance 
        = new Lazy<LazySingletonModern>(() => new LazySingletonModern());
    
    // 私有构造函数，防止外部直接创建实例
    private LazySingletonModern()
    {
        // 可以在构造函数中进行一些初始化操作
        Console.WriteLine("LazySingletonModern实例被创建");
    }
    
    // 公共静态属性，提供全局访问点
    public static LazySingletonModern Instance => lazyInstance.Value;
    
    // 业务方法
    public void ShowMessage()
    {
        Console.WriteLine("使用Lazy<T>的单例模式");
    }
}

特点：

  • 使用.NET提供的Lazy类，代码简洁
  • 线程安全，默认使用ThreadSafetyMode.ExecutionAndPublication模式
  • 实现延迟加载，第一次访问Instance属性时才创建实例
  • 结合了现代C#语法特性

单例模式的应用场景

单例模式适用于以下场景：
单例模式应用场景
需要唯一实例的场景
资源共享管理
协调全局行为
控制资源获取

  1. 资源共享管理

    • 数据库连接池：管理和复用数据库连接，避免频繁创建和销毁连接
    • 线程池：管理一组可复用的线程，减少线程创建和销毁的开销
    • 缓存管理：提供统一的缓存访问接口，共享缓存数据

  2. 系统级服务

    • 日志记录器：提供全局日志记录功能，确保日志内容被正确记录和管理
    • 配置管理器：集中管理应用程序配置，确保配置一致性
    • 设备管理器：管理系统设备资源，防止冲突

  3. UI组件

    • 对话框管理：确保只显示一个对话框实例
    • 拖放管理器：协调应用程序中的拖放操作
    • 剪贴板管理：提供对系统剪贴板的统一访问

  4. 其他常见应用

    • 应用程序状态管理
    • 注册表设置读写
    • 打印机后台处理程序
    • 文件系统管理

单例模式的优缺点

优点

  1. 控制共享资源：单例模式确保一个类只有一个实例，避免对共享资源的多重访问和冲突。

  2. 节省系统资源：避免创建多个实例，特别是对于需要消耗大量资源的对象，可以显著减少内存占用。

  3. 优化性能：对于频繁使用的对象，单例可以减少创建和销毁实例的开销，提高性能。

  4. 全局访问点：提供一个全局访问点，方便其他对象使用单例实例。

  5. 延迟加载：可以实现延迟加载（懒加载），在需要时才创建实例，提高启动性能。

缺点

  1. 违反单一职责原则：单例类既负责创建自己的实例，又负责业务逻辑，承担了两种责任。

  2. 测试困难：单例引入了全局状态，使得测试变得困难，因为测试通常依赖于状态隔离。

  3. 隐藏依赖关系：使用单例的类通常不会显式声明这种依赖关系，使代码的依赖不透明。

  4. 并发问题：如果单例实现不当，可能会在多线程环境下引发问题。

  5. 不易扩展：单例模式通常很难被继承和修改，如果需要扩展功能，往往需要修改原有代码。

单例模式的最佳实践

  1. 确保真正需要单例：在使用单例模式前，先确认是否真的需要一个类只有一个实例。有时依赖注入可能是更好的选择。

  2. 选择合适的实现方式：

    • 如果加载开销不大，可以使用饿汉式实现
    • 如果需要延迟加载，可以使用双重检查锁定或静态内部类实现
    • 在现代C#中，可以使用Lazy实现延迟加载和线程安全

  3. 考虑线程安全：在多线程环境下，确保单例的线程安全实现。

  4. 避免过度使用：单例模式虽然有用，但过度使用会导致系统耦合度高，难以测试和维护。

  5. 考虑依赖注入：在现代应用开发中，可以考虑使用依赖注入框架来管理单例生命周期，这样可以降低耦合度，提高可测试性。

  6. 处理序列化/反序列化：如果单例类需要序列化，确保在反序列化时不会创建新实例。

总结

单例模式是一种简单但功能强大的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在适当的场景下使用单例模式，可以有效地控制共享资源、节省系统资源并提高性能。

C#提供了多种实现单例模式的方式，从基本的懒汉式、饿汉式，到更加优化的双重检查锁定、静态内部类，以及现代C#中的Lazy实现。选择哪种实现方式取决于具体的应用场景和需求。

然而，单例模式也有其缺点，如违反单一职责原则、测试困难等。因此，在使用单例模式时，应当谨慎考虑，避免过度使用，并在适当的场景选择依赖注入等更现代的方法。

相关学习资源

  1. 书籍：

    • 《设计模式：可复用面向对象软件的基础》- Erich Gamma等（GoF，四人帮）
    • 《C#设计模式》- Gary McLean Hall
    • 《Head First设计模式》- Eric Freeman & Elisabeth Robson

  2. 网站资源：

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冰茶_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值