高性能内存缓存的线程安全

Question

我有一个静态内存缓存，每小时仅写入一次（或更长），并且由许多线程以极高的速率读取。传统观点建议我遵循如下模式：

public static class MyCache
{
    private static IDictionary<int, string> _cache;
    private static ReaderWriterLockSlim _sharedLock;

    static MyCache()
    {
        _cache = new Dictionary<int, string>();
        _sharedLock = new ReaderWriterLockSlim();
    }

    public static string GetData(int key)
    {
        _sharedLock.EnterReadLock();
        try
        {
            string returnValue;
            _cache.TryGetValue(key, out returnValue);
            return returnValue;
        }
        finally
        {
            _sharedLock.ExitReadLock();
        }
    }

    public static void AddData(int key, string data)
    {
        _sharedLock.EnterWriteLock();
        try
        {
            if (!_cache.ContainsKey(key))
                _cache.Add(key, data);
        }
        finally
        {
            _sharedLock.ExitWriteLock();
        }
    }
}

作为一个微优化的练习，我如何才能在共享 read 锁的相对开销中减少更多滴答声？ 编写的时间可能很昂贵，因为这种情况很少发生。我需要尽可能快地进行读取。在这种情况下，我可以只删除 read 锁（如下）并保持线程安全吗？或者有没有我可以使用的无锁版本？我熟悉内存防护，但不知道如何在这种情况下安全地应用它。

注意：我不拘泥于任何一种模式，所以只要最终结果更快并且在 C# 4.x.*中，任何建议都是受欢迎的。*

public static class MyCache2
{
    private static IDictionary<int, string> _cache;
    private static object _fullLock;

    static MyCache2()
    {
        _cache = new Dictionary<int, string>();
        _fullLock = new object();
    }

    public static string GetData(int key)
    {
        //Note: There is no locking here... Is that ok?
        string returnValue;
        _cache.TryGetValue(key, out returnValue);
        return returnValue;
    }

    public static void AddData(int key, string data)
    {
        lock (_fullLock)
        {
            if (!_cache.ContainsKey(key))
                _cache.Add(key, data);
        }
    }
}

Answer 1

当只有线程从数据结构中读取时，您不需要锁。因此，由于写入如此罕见（并且，我假设不是并发的），一个选项可能是制作字典的完整副本，对副本进行修改，然后以原子方式将旧字典与新字典交换：

public static class MyCache2
{
    private static IDictionary<int, string> _cache;

    static MyCache2()
    {
        _cache = new Dictionary<int, string>();
    }

    public static string GetData(int key)
    {
        string returnValue;
        _cache.TryGetValue(key, out returnValue);
        return returnValue;
    }

    public static void AddData(int key, string data)
    {
        IDictionary<int, string> clone = Clone(_cache);
        if (!clone.ContainsKey(key))
            clone.Add(key, data);
        Interlocked.Exchange(ref _cache, clone);
    }
}

Answer 2

我希望在这里实现无锁，并通过简单地不更改任何已发布的字典来实现线程安全。我的意思是：当您需要添加数据时，创建字典的完整副本，然后追加/更新/等副本。由于这是一个小时一次，即使对于大数据，这也不应该是一个问题。然后，当您进行更改后，只需将引用从旧字典交换到新字典（引用读/写保证是原子的）。

一个警告：任何需要在多个操作之间保持一致状态的代码都应该首先将字典捕获到一个变量中，即

var snapshot = someField;
// multiple reads on snapshot

这确保了所有相关逻辑都使用相同的版本数据，以避免在操作过程中交换引用时产生混淆。

我还会在写入时（而不是在读取时）使用锁，以确保不会对数据进行争吵。也有无锁的多写入器方法（主要是 Interlocked.CompareExchange 并在失败时重新应用），但我会先使用最简单的方法，而单个写入器正是如此。

Answer 3

替代选项：.net 1.x 哈希表（本质上是字典，减去泛型）有一个有趣的线程故事；读取在没有锁的情况下是线程安全的 - 您只需要使用锁来确保最多一个写入器。

所以：您可以考虑使用非泛型 Hashtable，不锁定读取，然后在写入期间锁定。

这是我有时仍然使用 Hashtable 的主要原因，即使在 .net 4.x 应用程序中也是如此。

但有一个问题 - 它会导致 int 键被装箱以进行存储和查询。

Answer 4

这只会在添加数据时复制字典。锁用于添加，但如果您不打算从多个线程添加，则可以将其取出。如果没有副本，则从原始字典中提取数据，否则在添加时使用副本。

以防副本在检查后被清空并被视为不为空，但在它能够检索值之前，我添加了一个 try catch，在这种罕见的事件中，它将从原始数据中提取数据，然后锁定，但同样，这种情况应该很少发生。

public static class MyCache2
{
    private static IDictionary<int, string> _cache;
    private static IDictionary<int, string> _cacheClone;
    private static Object _lock;

    static MyCache2()
    {
        _cache = new Dictionary<int, string>();
        _lock = new Object();
    }

    public static string GetData(int key)
    {
        string returnValue;
        if (_cacheClone == null)
        {
            _cache.TryGetValue(key, out returnValue);
        }
        else
        {
            try
            {
                _cacheClone.TryGetValue(key, out returnValue);
            }
            catch
            {
                lock (_lock)
                {
                    _cache.TryGetValue(key, out returnValue);
                }
            }
        }
        return returnValue;
    }

    public static void AddData(int key, string data)
    {
        lock (_lock)
        {
            _cacheClone = Clone(_cache);
            if (!_cache.ContainsKey(key))
                _cache.Add(key, data);
            _cacheClone = null;
        }
    }
}

Answer 5

您还可以查看无锁数据结构。 http://www.boyet.com/Articles/LockfreeStack.html 就是一个很好的例子