使缓存计算的结果成为线程安全的最高效方法是什么？

Question

（抱歉，如果在其他地方回答了这个问题；这似乎是一个常见问题，但事实证明很难搜索，因为“线程”和“缓存”等术语会产生压倒性的结果。）

我有一个昂贵的计算，其结果被频繁访问但很少更改。因此，我缓存了结果值。这是我的意思的一些 c# 伪代码：

int? _cachedResult = null;

int GetComputationResult()
{
    if(_cachedResult == null)
    {
        // Do the expensive computation.
        _cachedResult = /* Result of expensive computation. */;
    }
    return _cachedResult.Value;
}

在我的代码的其他地方，我偶尔会将 _cachedResult 设置回 null，因为计算的输入已更改，因此缓存的结果不再有效，需要重新计算。 （这意味着我不能使用Lazy<T>，因为Lazy<T> 不支持被重置。）

这适用于单线程场景，但当然它根本不是线程安全的。所以我的问题是：使GetComputationResult 线程安全的最高效方法是什么？

显然我可以把整个东西放在一个 lock() 块中，但我怀疑可能有更好的方法？ （可以进行原子检查以查看是否需要重新计算结果并仅在需要时才锁定的东西？）

非常感谢！

Answer 1

您可以使用双重检查锁定模式：

// Thread-safe (uses double-checked locking pattern for performance)
public class Memoized<T>
{
    Func<T> _compute;
    volatile bool _cached;
    volatile bool _startedCaching;
    volatile StrongBox<T> _cachedResult;  // Need reference type
    object _cacheSyncRoot = new object();

    public Memoized(Func<T> compute)
    {
        _compute = compute;
    }

    public T Value {
        get {
            if (_cached)    // Fast path
                return _cachedResult.Value;
            lock (_cacheSyncRoot)
            {
                if (!_cached)
                {
                    _startedCaching = true;
                    _cachedResult = new StrongBox<T>(_compute());
                    _cached = true;
                }
            }
            return _cachedResult.Value;
        }
    }

    public void Invalidate()
    {
        if (!_startedCaching)
        {
            // Fast path: already invalidated
            Thread.MemoryBarrier();  // need to release
            if (!_startedCaching)
                return;
        }
        lock (_cacheSyncRoot)
            _cached = _startedCaching = false;
    }
}

此特定实现符合您对在极端情况下应执行的操作的描述：如果缓存已失效，则该值应仅由单个线程计算一次，而其他线程应等待。但是，如果缓存在被访问的缓存值同时失效，则可能会返回陈旧的缓存值。

Answer 2

也许这会提供一些思考的食物:)。

1. 通用类。
2. 该类可以异步或同步计算数据。
3. 借助自旋锁实现快速读取。
4. 不在自旋锁内执行繁重的工作，只返回 Task，如有必要，在默认 TaskScheduler 上创建和启动 Task，以避免内联。

Task 与 Spinlock 的组合非常强大，可以用无锁的方式解决一些问题。

    using System;
    using System.Threading;
    using System.Threading.Tasks;

    namespace Example
    {
        class OftenReadSometimesUpdate<T>
        {
            private Task<T> result_task = null;
            private SpinLock spin_lock = new SpinLock(false);
            private TResult LockedFunc<TResult>(Func<TResult> locked_func)
            {
                TResult t_result = default(TResult);
                bool gotLock = false;
                if (locked_func == null) return t_result;

                try
                {
                    spin_lock.Enter(ref gotLock);
                    t_result = locked_func();
                }
                finally
                {
                    if (gotLock) spin_lock.Exit();
                    gotLock = false;
                }
                return t_result;
            }


            public Task<T> GetComputationAsync()
            {
                return
                LockedFunc(GetComputationTaskLocked)
                ;
            }
            public T GetComputationResult()
            {
                return
                LockedFunc(GetComputationTaskLocked)
                .Result
                ;
            }
            public OftenReadSometimesUpdate<T> InvalidateComputationResult()
            {
                return
                this
                .LockedFunc(InvalidateComputationResultLocked)
                ;
            }
            public OftenReadSometimesUpdate<T> InvalidateComputationResultLocked()
            {
                result_task = null;
                return this;
            }

            private Task<T> GetComputationTaskLocked()
            {
                if (result_task == null)
                {
                    result_task = new Task<T>(HeavyComputation);
                    result_task.Start(TaskScheduler.Default);
                }
                return result_task;
            }
            protected virtual T HeavyComputation()
            {
                //a heavy computation
                return default(T);//return some result of computation
            }
        }
    }

Answer 3

您可以简单地重新分配Lazy<T> 来实现重置：

Lazy<int> lazyResult = new Lazy<int>(GetComputationResult);

public int Result { get { return lazyResult.Value; } }

public void Reset()
{
   lazyResult = new Lazy<int>(GetComputationResult);
}