关于缓存线程安全 IEnumerable<T> 实现的性能

Question

我创建了ThreadSafeCachedEnumerable<T> 类，旨在提高重复使用长时间运行的查询的性能。这个想法是从IEnumerable<T> 获取一个枚举器，并在每次调用MoveNext() 时将项目添加到缓存中。以下是我目前的实现：

/// <summary>
/// Wraps an IEnumerable&lt;T&gt; and provides a thread-safe means of caching the values."/>
/// </summary>
/// <typeparam name="T"></typeparam>
class ThreadSafeCachedEnumerable<T> : IEnumerable<T>
{
    // An enumerator from the original IEnumerable<T>
    private IEnumerator<T> enumerator;

    // The items we have already cached (from this.enumerator)
    private IList<T> cachedItems = new List<T>();

    public ThreadSafeCachedEnumerable(IEnumerable<T> enumerable)
    {
        this.enumerator = enumerable.GetEnumerator();
    }

    public IEnumerator<T> GetEnumerator()
    {
        // The index into the sequence
        int currentIndex = 0;

        // We will break with yield break 
        while (true)
        {
            // The currentIndex will never be decremented,
            // so we can check without locking first
            if (currentIndex < this.cachedItems.Count)
            {
                var current = this.cachedItems[currentIndex];
                currentIndex += 1;
                yield return current;
            }
            else
            {
                // If !(currentIndex < this.cachedItems.Count),
                // we need to synchronize access to this.enumerator
                lock (enumerator)
                {
                    // See if we have more cached items ...
                    if (currentIndex < this.cachedItems.Count)
                    {
                        var current = this.cachedItems[currentIndex];
                        currentIndex += 1;
                        yield return current;
                    }
                    else
                    {
                        // ... otherwise, we'll need to get the next item from this.enumerator.MoveNext()
                        if (this.enumerator.MoveNext())
                        {
                            // capture the current item and cache it, then increment the currentIndex
                            var current = this.enumerator.Current;
                            this.cachedItems.Add(current);
                            currentIndex += 1;
                            yield return current;
                        }
                        else
                        {
                            // We reached the end of the enumerator - we're done
                            yield break;
                        }
                    }
                }
            }
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

当缓存中似乎没有更多项目时，我只是 lock (this.enumerator)，以防另一个线程即将添加另一个项目（我假设从两个线程调用 this.enumerator MoveNext() 是不好的想法）。

在检索以前缓存的项目时性能很好，但在第一次获取许多项目时它开始受到影响（由于不断锁定）。有什么提高性能的建议吗？

---

编辑：新的Reactive Framework 使用System.Linq.EnumerableEx.MemoizeAll() 扩展方法解决了上述问题。

在内部，MemoizeAll() 使用 System.Linq.EnumerableEx.MemoizeAllEnumerable<T>（在 System.Interactive 程序集中找到），类似于我的 ThreadSafeCachedEnumerable<T>（排序）。

这是一个非常人为的示例，它非常缓慢地打印 Enumerable（数字 1-10）的内容，然后再次快速打印内容（因为它缓存了值）：

// Create an Enumerable<int> containing numbers 1-10, using Thread.Sleep() to simulate work
var slowEnum = EnumerableEx.Generate(1, currentNum => (currentNum <= 10), currentNum => currentNum, previousNum => { Thread.Sleep(250); return previousNum + 1; });

// This decorates the slow enumerable with one that will cache each value.
var cachedEnum = slowEnum.MemoizeAll();

// Print the numbers
foreach (var num in cachedEnum.Repeat(2))
{
    Console.WriteLine(num);
}

Answer 1

一些建议：

1. 现在普遍接受的做法是不让容器类负责锁定。例如，调用缓存枚举器的人可能还希望在枚举时阻止将新条目添加到容器中，这意味着锁定会发生两次。因此，最好将此责任推给调用者。
2. 您的缓存依赖于始终按顺序返回项目的枚举器，这是无法保证的。最好使用Dictionary 或HashSet。同样，项目可能会在调用之间被删除，从而使缓存无效。
3. 一般不建议在可公开访问的对象上建立锁。这包括包装的枚举器。例外是可以想象的，例如，当您绝对确定您是唯一持有对您正在枚举的容器类的引用的实例时。这也将在很大程度上使我在 #2 下的反对意见无效。

Answer 2

.NET 中的锁定通常非常快（如果没有争用）。分析是否将锁定识别为性能问题的根源？在底层枚举器上调用MoveNext 需要多长时间？

此外，目前的代码不是线程安全的。您不能在一个线程（在if (currentIndex < this.cachedItems.Count)）上安全地调用this.cachedItems[currentIndex]，同时在另一个线程上调用this.cachedItems.Add(current)。来自List(T) documentation：“只要不修改集合，一个 List(T) 可以同时支持多个读取器。”为了线程安全，您需要使用锁保护对this.cachedItems 的所有访问（如果有可能一个或多个线程可以修改它）。