如何在C#中不使用Lazy<T>实现线程安全的延迟初始化单例？

1. 上述代码是否是规范的线程安全延迟初始化Singleton？ #

你写的是**双重检查锁定（Double-Check Locking）**的实现，但不算完全规范的线程安全版本——核心问题是instance字段没有加volatile修饰符。

在部分CPU架构或早期.NET环境中，JIT编译器可能对new Singleton()的执行指令重排：先给instance分配内存地址，再执行构造函数初始化。这会导致其他线程在第二次检查instance == null时，拿到一个已分配但未完全初始化的实例，进而引发未知错误。

在C# 2.0及以后版本中，给instance加上volatile修饰符就能禁止指令重排，让这个实现成为规范的线程安全延迟初始化单例：

public sealed class Singleton
{
    private static volatile Singleton instance = null; // 添加volatile修饰符
    private static readonly object padlock = new object();

    Singleton()
    {
    }

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

2. 该实现方式存在哪些潜在陷阱或性能问题？ #

潜在陷阱 #

• 未加volatile的指令重排风险：如上述所说，可能导致线程获取到未完全初始化的实例。
• 构造函数异常连锁问题：如果Singleton的构造函数抛出异常，后续线程进入锁内时instance依然为null，会反复尝试创建实例，引发持续异常。
• 锁对象误用隐患：如果padlock被改为非readonly，或在其他代码中复用这个锁对象，可能引发死锁或线程安全问题。

性能问题 #

• 锁竞争开销：高并发场景下，大量线程会在第一次null检查后进入锁等待，虽然双重检查已经减少了锁的触发频率，但锁竞争依然会带来性能损耗。
• 双重判断的累积开销：每次获取实例都要做两次null判断，单次开销极小，但在极端高频调用的场景下，累积起来也会有可感知的影响。

3. 有没有不使用Lazy的替代实现方法？ #

有几种常见的替代方案，各有适用场景：

方案1：饿汉式静态初始化（非延迟，但线程安全） #

利用CLR的静态字段初始化机制保证线程安全，缺点是程序启动时就会创建实例，无法实现真正的延迟初始化：

public sealed class Singleton
{
    // CLR在第一次访问类时自动初始化，天然线程安全
    private static readonly Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static Singleton Instance => instance;
}

方案2：静态内部类实现（延迟+线程安全） #

这是.NET环境下推荐的延迟初始化单例实现之一，利用CLR加载内部类的时机实现延迟，同时由CLR保证静态字段初始化的线程安全：

public sealed class Singleton
{
    private Singleton() {}
    
    // 静态内部类不会在外部类加载时初始化，只有第一次访问Instance时才会加载
    private static class SingletonHolder
    {
        internal static readonly Singleton Instance = new Singleton();
    }
    
    public static Singleton Instance => SingletonHolder.Instance;
}

方案3：使用Interlocked原子操作（无锁实现） #

通过原子操作避免锁的开销，缺点是可能会多次创建Singleton实例，但只有第一个成功赋值的实例会被返回（适合构造函数无副作用的场景）：

public sealed class Singleton
{
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                // 先创建临时实例，再通过原子操作替换instance
                var tempInstance = new Singleton();
                Interlocked.CompareExchange(ref instance, tempInstance, null);
            }
            return instance;
        }
    }
}

内容的提问来源于stack exchange，提问作者Fatih Furkan Çambel