C# 一分钟浅谈：设计模式之单例模式

创作时间:

作者:

@小白创作中心

C# 一分钟浅谈：设计模式之单例模式

引用

来源

https://developer.aliyun.com/article/1627706

单例模式是软件开发中最简单也是最常用的设计模式之一。它确保一个类只有一个实例，并提供一个全局访问点。本文将从单例模式的基本概念出发，逐步深入探讨其实现方式、常见问题、易错点及如何避免这些问题，并通过代码示例进行详细说明。

单例模式的基本概念

单例模式的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于那些需要频繁创建和销毁的对象，或者那些在整个应用程序生命周期中只需要一个实例的对象。

优点

资源消耗低：由于整个应用程序中只有一个实例，因此可以节省内存。
全局访问：提供了一个全局访问点，方便在任何地方使用该实例。
控制共享资源：可以更好地控制对共享资源的访问，例如数据库连接、线程池等。

缺点

滥用单例：如果过度使用单例模式，可能会导致代码耦合度增加，难以测试和维护。
多线程问题：在多线程环境中，如果不加锁处理，可能会导致多个实例的创建。

单例模式的实现方式

饿汉式（Eager Initialization）

饿汉式是最简单的单例模式实现方式，它在类加载时就创建了实例。这种方式是线程安全的，但可能会浪费资源，因为实例在程序启动时就被创建了，即使不使用也会占用内存。

public class Singleton
{
    // 在静态构造函数中创建实例
    private static readonly Singleton _instance = new Singleton();
    // 私有构造函数，防止外部实例化
    private Singleton() {
    }
    // 提供全局访问点
    public static Singleton Instance
    {
        get {
            return _instance; }
    }
}

懒汉式（Lazy Initialization）

懒汉式在第一次使用时才创建实例，这种方式可以节省资源，但需要处理多线程问题。

线程不安全的懒汉式

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

线程安全的懒汉式

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;
        }
    }
}

使用 Lazy 实现线程安全的懒汉式

Lazy 是 .NET 框架提供的一个类，可以方便地实现线程安全的懒汉式单例。

public class Singleton
{
    private static readonly Lazy<Singleton> _lazy = new Lazy<Singleton>(() => new Singleton());
    private Singleton() {
    }
    public static Singleton Instance
    {
        get {
            return _lazy.Value; }
    }
}

常见问题与易错点

多线程问题

在多线程环境中，如果不加锁处理，可能会导致多个实例的创建。如上所述，可以通过双检锁（Double-Check Locking）或使用 Lazy 来解决这个问题。

序列化问题

在某些情况下，单例对象可能需要被序列化和反序列化。如果直接序列化和反序列化单例对象，可能会导致多个实例的创建。可以通过实现 ISerializable 接口来解决这个问题。

[Serializable]
public class Singleton : ISerializable
{
    private static readonly Singleton _instance = new Singleton();
    private static readonly object _lock = new object();
    private Singleton() {
    }
    public static Singleton Instance
    {
        get {
            return _instance; }
    }
    protected Singleton(SerializationInfo info, StreamingContext context)
    {
        // 反序列化时返回现有的实例
        _instance = (Singleton)info.GetValue("Instance", typeof(Singleton));
    }
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Instance", _instance);
    }
}

反射问题

通过反射，可以在运行时创建私有构造函数的实例，从而破坏单例模式。可以通过在构造函数中添加检查来防止这种情况。

public class Singleton
{
    private static readonly Singleton _instance = new Singleton();
    private static bool _isInitialized = false;
    private Singleton()
    {
        if (_isInitialized)
        {
            throw new InvalidOperationException("Singleton instance already created.");
        }
        _isInitialized = true;
    }
    public static Singleton Instance
    {
        get {
            return _instance; }
    }
}