c# - 线程安全惰性类

Question

我有一个 Lazy 类，它懒惰地计算一个表达式:

public sealed class Lazy<T>
{
    Func<T> getValue;
    T value;

    public Lazy(Func<T> f)
    {
        getValue = () =>
            {
                lock (getValue)
                {
                    value = f();
                    getValue = () => value;
                }
                return value;
            };
    }

    public T Force()
    {
        return getValue();
    }
}

基本上，我试图避免在评估对象后锁定对象的开销，因此我将 getValue 替换为调用时的另一个函数。

它显然在我的测试中有效，但我无法知道它是否会在生产中爆炸。

我的类是线程安全的吗？如果不是，如何保证线程安全？

Answer 1

你不能通过使用标志或保护值来完全省略对函数的重新评估吗？即:

public sealed class Lazy<T>
{
    Func<T> f;
    T value;
    volatile bool computed = false;
    void GetValue() { lock(LockObject) { value = f();  computed = true; } }

    public Lazy(Func<T> f)
    {
        this.f = f;
    }

    public T Force()
    {
        if (!computed) GetValue();
        return value;
    }
}