使用双重检查锁定的内存读取可见性排序与写入顺序

Question

我有以下函数，旨在“memoize”无参数函数。 意思是只调用一次函数，然后在其他时间返回相同的结果。

private static Func<T> Memoize<T>(Func<T> func)
{
    var lockObject = new object();
    var value = default(T);
    var inited = false;

    return () => {
        if (inited)
            return value;

        lock (lockObject) {
            if (!inited) {
                value = func();
                inited = true;
            }
        }

        return value;
    };
}

我可以确定如果一个线程在锁外读取“inited == true”，那么它将读取在“inited”设置为true之前写入的“值”吗？

注意： .NET中的双重检查锁定涵盖了它应该工作的事实，这个问题主要是检查我的实现是否正确并且可能获得更好的替代方案。

Answer 1

不，因为inited volatile 。 volatile为您提供内存释放并获取您需要的围栏，以便建立正确的先发生关系。

如果在inited之前没有释放围栏设置为true，那么在另一个线程读inited并且将其视为真时，该value可能不会完全写入，这可能导致返回半构造的对象。 同样，如果有一个释放的围栏，但读数之前没有相应的获取栅栏inited在第一次检查，有可能是该对象被完全构造，但是，看到CPU核心inited为真还没有见过的记忆效应value感写入（缓存一致性并不一定要求在其他核心上按顺序看到连续写入的影响）。 这将再次潜在地导致返回半构造的对象。

顺便说一下，这是已经非常详细记录的双重检查锁定模式的实例。

我建议不要使用捕获局部变量的lambda（这会使编译器生成一个隐式类来保存非易失性字段中的闭合变量），而是建议使用volatile属性value明确创建自己的类。

private class Memoized<T>
{
    public T value;
    public volatile bool inited;
}

private static Func<T> Memoize<T>(Func<T> func)
{
    var memoized = new Memoized<T>();

    return () => {
        if (memoized.inited)
            return memoized.value;

        lock (memoized) {
            if (!memoized.inited) {
                memoized.value = func();
                memoized.inited = true;
            }
        }

        return memoized.value;
    };
}

当然，正如其他人所说， Lazy<T>为了这个目的而存在的。 使用它而不是自己动手，但了解事物如何运作的理论总是一个好主意。

Answer 2

我认为你最好使用标准的Lazy<T>类来实现你需要的功能，如：

private static Func<T> Memoize<T>(Func<T> func)
{
    var lazyValue = new Lazy<T>(func, isThreadSafe: true);
    return () => lazyValue.Value;
}

Answer 3

不，那段代码不安全。 编译器可以自由地inited对value和inited的写入; 内存系统也是如此。 这意味着另一个线程可能会将inited设置为true而value仍然是默认值。

这种模式称为双重检查锁定，Albahari在Lazy Initialization下讨论。 建议的解决方案是使用内置的Lazy<T>类。 等效实现如下：

private static Func<T> Memoize<T>(Func<T> func)
{
    var lazy = new Lazy<T>(func);
    return () => lazy.Value;
}