具有易失性或内存屏障的双锁

Question

这是我已有的代码，运行了几个月没有任何问题。

public sealed class Singleton 
{
    private static Singleton value;
    private static object syncRoot = new Object();
    public static Singleton Value 
    {
        get 
        {
            if (Singleton.value == null) 
            {
                lock (syncRoot) 
                {
                    if (Singleton.value == null) 
                    {
                        Singleton.value = new Singleton();
                    }
                }
            }
            return Singleton.value;
        }
    }      
}

但是，我遇到了这个link，它概述了上述问题。

a) 写入Singleton.value = new Singleton(); 可能会缓存在处理器上，因此其他线程可能最终看不到它。使用volatile 关键字修复此问题。

Q(1)：C# lock 关键字不处理这个问题吗？

b) 在同一篇文章中概述的另一个更好的解决方案是避免volatile，并在写入Singleton.value 之后引入System.Threading.Thread.MemoryBarrier();。

问题：

Q(2) 写完后我不太明白MemoryBarrier() 的必要性。什么可能的重新排序可能会导致其他线程将 Singleton.value 视为 null ？ lock 阻止其他线程甚至读取任何内容。

Q(3) 屏障只会维持顺序，但如果仍然从某个缓存中读取值怎么办。 volatile 还不需要吗？

Q(4) 既然 C# lock 自己放置了屏障，那里真的需要屏障吗？

最后， 我需要用这两种方法更新我的代码还是足够好？

修改 有一个答案建议使用Lazy 初始化。我得到了它。

但是他们试图使用锁不能保证的 volatie 和 memorybarrier 来完成什么？

Answer 1

这是我已有的代码，运行了几个月没有任何问题。

如果有十亿分之一的失败几率，并且代码每天在 1000 台机器上运行一千次，那么平均每三年就会出现一次无法调试的严重故障。

如果它只在特定硬件上失败，并且您在 x86 上进行了所有测试，那么您将永远不会看到失败。

没有测试低锁定代码的正确性这样的事情。该代码要么被证明是正确的，要么不是。你不能依赖测试。

C# lock 关键字不处理这个问题吗？

锁在其中一个读取上被删除。

锁阻止其他线程甚至读取任何内容。

锁在其中一个读取上被删除。

Barriers 只会维持顺序，但如果仍然从某个缓存中读取该值会怎样。 volatile 还不需要吗？

从缓存中读取相当于将读取时间向后移动；由易变或显式障碍引起的障碍对如何观察这种向后移动施加了限制。

因为 C# lock 本身就设置了屏障，那里真的需要屏障吗？

锁在其中一个读取上被删除。

我需要用这两种方法更新我的代码还是足够好？

我永远不会写这样的代码。如果需要延迟初始化，请使用Lazy<T>。如果您需要单例，请使用单例模式的标准实现。不要自己解决这些问题；让专家为您解决这些问题。

但是他们试图使用锁不能保证的 volatile 和 memorybarrier 来完成什么？

他们试图正确地忽略一个锁，从而在非竞争路径中节省几纳秒。与难以调试的罕见严重故障的成本相比，这些纳秒对您的用户有何价值？

任何时候你试图摆脱一个锁，你都会完全沉浸在低级内存模型的疯狂世界中。你必须假设所有的记忆都在不断变化，除非有什么东西让它保持不动；您必须假设任何和所有合法的内存访问重新排序都是可能的，甚至在大多数硬件上都是不可能的。你不知道未来会发明什么奇怪的硬件来运行你的代码。

不要去那里。我不喜欢使用线程；如果我想并行化某些东西，我的偏好是在问题上抛出虚拟机、容器或进程。如果必须使用线程，请尽量不要共享内存。如果您必须共享内存，请使用由专家构建的最高级别的构造，例如 Task 和 Lazy，而不是滚动您自己的内存屏障和互锁操作。

Answer 2

正如其他人所提到的，您只需使用 Lazy 为您生成实例就可以省去很多麻烦：

public sealed class Singleton 
{
    private static Lazy<Singleton> _value = new Lazy<Singleton>(() => new Singleton());

    public static Singleton Value => _value.Value;
}

正如比我聪明得多的人指出的那样，大多数情况下，这可以通过使用静态初始化器来简化：

public sealed class Singleton 
{
    public static Singleton Value = new Singleton();
}

请参阅 Eric Lippert 在我的回答中的 cmets，了解这些方法之间的主要区别以及可能有助于您在其中一种或另一种之间做出决定的因素。