Question

我实现了一个由ConcurrentDictionary支持的简单内存缓存

public class MemoryCache 
{
    private ConcurrentDictionary<string, CacheObject> _memory;

    public MemoryCache()
    {
        this._memory = new ConcurrentDictionary<string, CacheObject>();
    }


    private bool TryGetValue(string key, out CacheObject entry)
    {
        return this._memory.TryGetValue(key, out entry);
    }

    private bool CacheAdd(string key, object value, DateTime? expiresAt = null)
    {
        CacheObject entry;
        if (this.TryGetValue(key, out entry)) return false;

        entry = new CacheObject(value, expiresAt);
        this.Set(key, entry);

        return true;

    }

    public object Get(string key)
    {
        long lastModifiedTicks;
        return Get(key, out lastModifiedTicks);
    }

    public object Get(string key, out long lastModifiedTicks)
    {
        lastModifiedTicks = 0;
        CacheObject CacheObject;
        if (this._memory.TryGetValue(key, out CacheObject))
        {
            if (CacheObject.HasExpired)
            {
                this._memory.TryRemove(key, out CacheObject);
                return null;
            }
            lastModifiedTicks = CacheObject.LastModifiedTicks;
            return CacheObject.Value;
        }
        return null;
    }

    public T Get<T>(string key)
    {
        var value = Get(key);
        if (value != null) return (T)value;
        return default(T);
    }


    public bool Add<T>(string key, T value)
    {
        return CacheAdd(key, value);
    }
}

现在我正在尝试使用基于@ayende的blog post的代码对其进行测试。

var w = new ManualResetEvent(false);
var threads = new List<Thread>();
for (int i = 0; i < Environment.ProcessorCount; i++)
{
    threads.Add(new Thread(() =>
    {
        w.WaitOne();
        DoWork(i);
    }));
    threads.Last().Start();
}

w.Set();//release all threads to start at the same time
foreach (var thread in threads)
{
    thread.Join();
}

所以DoWork调用一个包含单例缓存管理器的进程，在我的情况下，它会从系统中进行身份验证并返回一个令牌。然后，该令牌与唯一密钥（用户名）一起存储。现在每个调用，在我的情况下有8个内核/线程，用户名是相同的，让我们说“BobUser：CacheKey”。

每次运行代码时，我都会看到正在发出8个请求，因为缓存Get始终返回null。

var token = _cm.Cache.Get<MyToken>(userId);
if (token != null) return token;
token = base.Logon(userId, password);
if (token != null)
{
    _cm.Cache.Add(userId, token);
}
return token;

这真的是因为8个线程在同一时间完全交互吗？如果是这种情况，是否有解决此并发问题的模式？

谢谢你，斯蒂芬

Answer 1

之所以发生这种情况，是因为为了让缓存启动，至少有一个线程必须完全完成身份验证，并在其他线程甚至到达顶部的.Get()调用之前添加到缓存中。

var token = _cm.Cache.Get<MyToken>(userId); // <-------------------------------+
if (token != null) return token;            //                                 |
token = base.Logon(userId, password);       //                                 |
if (token != null)                          //                                 |
{                                           //                                 |
    _cm.Cache.Add(userId, token); //<-- A thread needs to execute this before  |
                                  // other threads even execute this  ----------
}
return token;

通过阻止线程并在大致相同的时间启动它们，可以使事情变得更糟。如果要修复它，请在身份验证周围添加lock，以便一次只能发出一个身份验证请求。

示例可能如下所示：

private static object AuthenticationLocker = new object();
private string GetToken(string userId)
{
    lock (AuthenticationLocker)
    {
        var token = _cm.Cache.Get<MyToken>(userId);
        if (token != null) return token;
        token = base.Logon(userId, password);
        if (token != null)
        {
            _cm.Cache.Add(userId, token);
        }
        return token;
    }
}

请注意，如果您确实开始使用锁，则可以使用常规缓存，而不是线程安全缓存。

如果您不想使用锁，那么您需要接受这样一个事实，即您可能同时调度多个请求。你无法双管齐下

Answer 2

查看So how does ConcurrentDictionary do better?

部分

读取没有锁定，因此如果它们都在数据实际存在之前尝试读取它们将全部收到空值。

当使用多个并发线程时，为什么ConcurrentDictionary返回的值始终为null？

2 个答案: