65.9K
CodeProject 正在变化。 阅读更多。
Home

C# 中的线程安全单例：双重检查锁定和 Lazy<T> 方法指南

Antonio Ripa
starIconstarIconstarIconstarIconstarIcon

5.00/5 (12投票s)

2024 年 9 月 10 日

CPOL

10分钟阅读

viewsIcon

17480

一份关于在 C# 中实现线程安全单例模式的实用指南，涵盖现代和传统方法，包括每种方法都表现出色的实际场景。

引言

设计模式是解决常见软件设计问题的久经考验的解决方案。它们提供了一种标准的解决重复性问题的方法，使代码更灵活、可重用且易于理解。本文是探索流行设计模式系列的第一篇，从单例模式开始。

单例模式确保一个类只有一个实例，并提供对该实例的全局访问点。在本篇文章中，我们将探讨如何在 C# 中实现线程安全的单例，使用经典的双重检查锁定模式和更现代的Lazy<T> 方法。我们还将探讨双重检查锁定更适合的实际场景。

背景

为什么要使用单例？

单例模式保证一个类只有确切的一个实例，并提供对该实例的全局访问点。它通常用于需要单个、集中的对象的任务，例如配置管理器、日志记录器或连接池。

单例模式的一些典型用例包括

  • 日志记录：拥有一个写入文件或控制台的单一日志记录对象，可确保一致的日志记录行为。
  • 配置管理：单例对于管理仅在应用程序生命周期中初始化一次的配置设置很有用。
  • 数据库连接：单例可用于管理与数据库的共享连接，从而减少资源开销。
C# 中的基本单例示例
public class Singleton
{
    private static Singleton _instance;

    // Private constructor to prevent instantiation from outside
    private Singleton() { }

    // Public static method to access the single instance
    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new Singleton();
            }
            return _instance;
        }
    }

    public void DoSomething()
    {
        Console.WriteLine("Singleton instance method called!");
    }
}

在此基本实现中

  • 私有构造函数：确保外部类无法创建 Singleton 的新实例。
  • 静态字段：保存类的唯一实例。
  • Instance 属性：提供对实例的全局访问，并在实例尚不存在时创建它（延迟初始化）。
如何调用单例
class Program
{
    static void Main(string[] args)
    {
        // Accessing the Singleton instance for the first time
        Singleton instance1 = Singleton.Instance;
        instance1.DoSomething();

        // Accessing the Singleton instance again
        Singleton instance2 = Singleton.Instance;

        // Verifying that both references point to the same object
        if (Object.ReferenceEquals(instance1, instance2))
        {
            Console.WriteLine("Both instances are the same.");
        }
        else
        {
            Console.WriteLine("Instances are different.");
        }

        // Example output:
        // "Singleton instance method called!"
        // "Both instances are the same."
    }
}

在这里，Singleton 类通过 Instance 属性访问。由于单例模式确保只创建一个类的实例，因此对 Singleton.Instance 的所有引用都将指向同一个对象。这允许您调用 DoSomething 方法，并确保在应用程序中一致地使用单例对象。 

  • ReferenceEquals(instance1, instance2) 检查 instance1 和 instance2 是否引用内存中的同一对象。
  • 使用单例模式时，instance1 和 instance2 都将引用同一个实例，并且程序将打印“两个实例相同。”

这表明无论多少次调用 Instance 属性，它始终返回相同的对象，从而确保应用程序中只有一个 Singleton 类的实例。

多线程问题

在多线程环境中工作时，确保只创建一个单例实例可能很棘手。这就是线程安全实现发挥作用的地方。

为了说明在没有锁的情况下，单例的多线程问题，这里有一个例子

假设您有一个 StaticDataManager 类，其中有一个 GetCountries 方法，该方法从数据库获取数据并填充国家/地区列表。如果没有适当的同步，多个线程可能会同时尝试创建单例实例，从而导致不可预测的行为甚至重复实例。

无线程安全示例

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

public class StaticDataManager
{
    private static ConfigurationManager _instance;
    private List<string> _countries;

    private ConfigurationManager()
    {
        _countries = new List<string>();
        LoadCountriesFromDatabase();
    }

    public static ConfigurationManager Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new StaticDataManager();
            }
            return _instance;
        }
    }

    public List<string> GetCountries()
    {
        return _countries;
    }


    private void LoadCountriesFromDatabase()
    {
       // Here we are reading the CountryName from the database 
       // and adding it to the _countries list variable _countries
    }
}

问题说明

如果多个线程同时调用 StaticDataManager.Instance，则会发生竞态条件：两个或多个线程可能在 _instance 变量被设置之前创建自己的 StaticDataManager 实例，从而导致多个实例和冗余数据库调用。

这种情况可能导致

  1. 创建多个实例：如果没有适当的同步，不同的线程可能会创建 StaticDataManager 的独立实例，从而导致多个数据库连接或不必要的资源消耗。

  2. 冗余数据库调用：每个线程可能独立地从数据库获取相同的数据，导致同时执行多个相同的查询，从而不必要地增加了负载和延迟。

在实际应用程序中，这可能导致行为不一致、资源消耗增加或数据处理不正确。

还有一个风险：如果一个线程正在初始化 StaticDataManager （例如，它仍在从数据库加载数据），而另一个线程在初始化完成之前尝试访问 GetCountries 方法，会怎么样？

  1. 线程 1 开始初始化过程，并开始从数据库加载国家/地区列表。
  2. 线程 2 在线程 1 仍在获取数据时调用 GetCountries()。由于线程 2 在 _countries 完全填充之前访问它，因此它可能会收到不完整的列表（如果初始化尚未添加任何条目，甚至可能是空列表）。

在这种情况下，第二个线程可能会访问不完整的 _countries 列表，导致返回的数据不正确或不完整。这会引入数据不一致，导致应用程序的不同部分可能操作不完整或不正确的数据。

解决方案

通过实现适当的同步机制（如锁定）来解决此问题，以确保

  • 只有一个线程可以创建 StaticDataManager 实例。
  • 在初始化完全完成之前，任何线程都不能通过 GetCountries 访问数据。

通过实现双重检查锁定或使用Lazy<T>，您可以防止竞态条件以及第二个线程在初始化完成之前访问数据的场景。这确保了对单例实例的线程安全访问以及整个应用程序的数据一致性。

经典方法：双重检查锁定

传统上，双重检查锁定模式用于在 C# 中创建线程安全的单例。此方法的目标是通过仅在必要时（即在第一次初始化期间）锁定实例创建代码来最小化性能成本。

具有双重检查锁定的经典单例

这是使用双重检查锁定实现单例的方法

public class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();

    private Singleton() 
    {
    }

    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new Singleton();
                    }
                }
            }
            return _instance;
        }
    }
}

工作原理

  • 第一次空检查：在获取锁之前，代码会检查实例是否已创建。如果未创建，则会进入锁定块。
  • 锁定：如果尚未创建实例，则代码会锁定关键部分，以确保没有其他线程可以同时创建实例。
  • 第二次空检查：获取锁后，它会再次检查实例是否仍然为 null。这是为了避免竞态条件，即多个线程可能会通过第一次检查并尝试同时创建实例。

为什么要使用双重检查锁定？

双重检查锁定可确保单例实例延迟初始化且线程安全，并且重点是性能优化。以下是此方法为何重要的原因

  1. 延迟初始化：单例实例仅在首次需要时创建，而不是在应用程序启动时创建，从而节省资源并可能避免不必要的数据库连接或对象创建。

  2. 减少锁定开销：没有双重检查锁定，lock 语句将每次访问 Instance 属性时都会执行，即使单例实例已创建。这种持续锁定会带来不必要的开销，尤其是在单例被频繁访问的高性能或多线程环境中。 

    • 使用双重检查锁定，该方法首先检查实例是否已创建，而无需获取锁（第一次空检查）。如果实例存在，则完全跳过锁定，在单例已初始化的常见情况下可显著提高性能。

  3. 线程安全性：在单例尚未创建的第一次访问期间，锁可确保只有一个线程初始化实例。初始化后，后续线程会绕过锁，从而避免了将来访问的性能损失。

  4. 避免竞态条件：通过使用两次检查，可以确保一旦线程进入 lock 块，它会在创建实例之前重新检查实例的状态，从而防止多个线程同时创建不同的实例。

性能比较

没有双重检查锁定，对单例的每次访问都需要锁定，这可能成本高昂，尤其是在高并发应用程序中。相比之下，使用双重检查锁定，一旦初始化了单例，所有将来的访问都会绕过锁定，从而提供近乎即时的访问而没有开销。

总之，双重检查锁定通过确保锁定仅在绝对必要时（首次创建实例期间）应用，在线程安全和性能之间取得平衡。但是，在现代 C# 开发中，使用 Lazy<T> 提供了一种更简单、更有效的方法来实现类似的结果。

现代方法：使用 Lazy<T>

在 C# 4.0 及更高版本中，Microsoft 引入了 Lazy<T> 类，它简化了线程安全的延迟初始化。现在它是实现单例的首选方式，因为它抽象了锁定和初始化的复杂性。

使用 Lazy<T> 的单例

public class Singleton
{
    private static readonly Lazy<Singleton> _instance = new Lazy<Singleton>(() => new Singleton());

    private Singleton() 
    {
    }

    public static Singleton Instance => _instance.Value;
}

 

使用 Lazy<T> 的好处

  • 内置线程安全性：Lazy<T> 确保单例实例仅创建一次，且方式是线程安全的。
  • 简单性：代码比双重检查锁定更简洁、更易于理解。
  • 延迟初始化：单例实例仅在首次访问时创建。

这是使用 Lazy<T> 方法的 StaticDataManager 的代码

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

public class StaticDataManager
{
    // Lazy initialization of the singleton instance
    private static readonly Lazy<StaticDataManager> _instance = 
        new Lazy<StaticDataManager>(() => new StaticDataManager());

    private List<string> _countries;

    // Private constructor to prevent instantiation from outside
    private StaticDataManager()
    {
        _countries = new List<string>();
        LoadCountriesFromDatabase();
    }

    // Public accessor for the singleton instance
    public static StaticDataManager Instance => _instance.Value;

    public List<string> GetCountries()
    {
        return _countries;
    }

    // Simulated database call to load countries
    private void LoadCountriesFromDatabase()
    {
        // Here we are reading the CountryName from the database
        // and adding it to the _countries list variable _countries
    }
}

何时 Lazy<T> 就足够了

对于大多数现代应用程序，使用 Lazy<T> 是实现单例的最佳方法。它开箱即用地处理线程安全和延迟初始化，并且代码更简单、更易于维护。

 

何时使用双重检查锁定：实际示例

尽管 Lazy<T> 适用于大多数情况，但在某些情况下，双重检查锁定方法仍然更合适。其中一种情况是当您需要根据运行时参数有条件地初始化单例实例时。

场景：动态配置管理器

让我们考虑一个示例，在该示例中，您需要根据运行时环境从不同来源加载配置设置。如果应用程序处于开发模式，配置将从本地文件加载；如果处于生产模式，配置将从数据库加载。Lazy<T> 不允许这种动态初始化逻辑，但双重检查锁定可以。

这是实现动态配置管理器的方法

public class ConfigurationManager
{
    private static ConfigurationManager _instance;
    private static readonly object _lock = new object();

    private string _configurationSource;

    // Private constructor
    private ConfigurationManager(string configurationSource)
    {
        _configurationSource = configurationSource;
        LoadConfiguration();
    }

    private void LoadConfiguration()
    {
        if (_configurationSource == "File")
        {
            Console.WriteLine("Loading configuration from file...");
            // Load from file
        }
        else if (_configurationSource == "Database")
        {
            Console.WriteLine("Loading configuration from database...");
            // Load from database
        }
    }

    public static ConfigurationManager GetInstance(string environment)
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    string configSource = environment == "Development" ? "File" : "Database";
                    _instance = new ConfigurationManager(configSource);
                }
            }
        }
        return _instance;
    }
}

为什么要在这里使用双重检查锁定？

在这种情况下，双重检查锁定为您提供了在初始化期间将动态参数传递给单例实例的灵活性。Lazy<T> 不提供这种灵活性，因为它假设初始化逻辑在编译时是固定的。

主要收获

  • 动态初始化：如果初始化逻辑依赖于运行时参数（如环境特定配置），则双重检查锁定更灵活。
  • 控制初始化：双重检查锁定允许 Lazy<T> 难以轻松支持的更复杂的初始化场景。

进一步开发

虽然双重检查锁定和 Lazy<T> 为线程安全的单例初始化提供了可靠的解决方案，但还可以根据应用程序的特定需求考虑进一步的增强

  1. 依赖注入 (DI)：在现代应用程序中，尤其是在 ASP.NET Core 等框架中，使用依赖注入有时比单例更好。它确保了对象的受控且可测试的生命周期管理，而没有单例可能引入的全局状态问题。

  2. 急切初始化：在性能至关重要且实例创建成本可忽略不计的情况下，可以使用急切初始化。此方法在应用程序启动时预先实例化单例，完全避免了任何锁定或延迟实例化逻辑。但是，这仅在您确定单例将始终被使用时才适用。

  3. 异步延迟初始化：如果您的单例初始化涉及异步操作（例如，I/O 绑定的任务，如数据库连接），您可以将 Lazy<T> 与 async 结合使用。这允许在异步场景中进行非阻塞、线程安全的单例创建。

  4. 自定义线程安全缓存：如果您的单例管理大量数据，您可以结合自定义缓存机制（例如，使用 MemoryCache 或线程安全字典）来提高访问速度并避免不必要的数据库调用。

  5. 版本化单例：对于高级场景，您可以实现版本化单例，其中应用程序的各个部分需要不同的配置或实例。这对于将单例表示状态对象的系统（例如，不同租户的不同数据库连接或配置）很有用。

通过考虑这些技术，您可以调整单例模式以更好地满足项目中特定的性能、并发性或可伸缩性需求。

结论

虽然 Lazy<T> 是现代 C# 开发中线程安全、延迟单例初始化的首选方法，但仍有一些场景双重检查锁定更可取。如果您的单例初始化需要动态参数或基于运行时条件的复杂决策，双重检查锁定提供了必要的灵活性。

然而，在大多数情况下，Lazy<T> 的简单性和优雅性使其成为首选。一如既往，正确的解决方案取决于您应用程序的具体需求。

© . All rights reserved.