Question

替换与ConcurrentDictionary键关联的值是否会锁定超出该键的任何字典操作？

编辑：例如，我想知道除了首次添加密钥之外，其中一个线程是否会阻止另一个线程，如下所示：

public static class Test {
    private static ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>();
    public static Test() {
        new Thread(UpdateItem1).Start();
        new Thread(UpdateItem2).Start();
    }
    private static void UpdateItem1() {
        while (true) cd[1] = 0;
    }
    private static void UpdateItem2() {
        while (true) cd[2] = 0;
    }
}

最初我认为它确实如此，因为例如dictionary[key] = value;可以引用尚未出现的密钥。但是，在工作时我意识到如果需要添加，可能会在单独的锁升级后发生。

我正在起草下面的类，但如果这个问题（上面）的答案是“否”，那么AccountCacheLock类提供的间接是不必要的。事实上，我自己的锁管理几乎都是不必要的。

// A flattened subset of repository user values that are referenced for every member page access
public class AccountCache {

    // The AccountCacheLock wrapper allows the AccountCache item to be updated in a locally-confined account-specific lock.
    // Otherwise, one of the following would be necessary:
    // Replace a ConcurrentDictionary item, requiring a lock on the ConcurrentDictionary object (unless the ConcurrentDictionary internally implements similar indirection)
    // Update the contents of the AccountCache item, requiring either a copy to be returned or the lock to wrap the caller's use of it.
    private static readonly ConcurrentDictionary<int, AccountCacheLock> dictionary = new ConcurrentDictionary<int, AccountCacheLock>();

    public static AccountCache Get(int accountId, SiteEntities refreshSource) {
        AccountCacheLock accountCacheLock = dictionary.GetOrAdd(accountId, k => new AccountCacheLock());
        AccountCache accountCache;
        lock (accountCacheLock) {
            accountCache = accountCacheLock.AccountCache;
        }
        if (accountCache == null || accountCache.ExpiresOn < DateTime.UtcNow) {
            accountCache = new AccountCache(refreshSource.Accounts.Single(a => a.Id == accountId));
            lock (accountCacheLock) {
                accountCacheLock.AccountCache = accountCache;
            }
        }
        return accountCache;
    }

    public static void Invalidate(int accountId) {
        // TODO
    }

    private AccountCache(Account account) {
        ExpiresOn = DateTime.UtcNow.AddHours(1);
        Status = account.Status;
        CommunityRole = account.CommunityRole;
        Email = account.Email;
    }

    public readonly DateTime ExpiresOn;
    public readonly AccountStates Status;
    public readonly CommunityRoles CommunityRole;
    public readonly string Email;

    private class AccountCacheLock {
        public AccountCache AccountCache;
    }
}

附带问题：ASP.NET框架中是否已经存在这样的问题？

Answer 1

您不需要做任何锁定。 ConcurrentDictionary应该很好地处理它。

附带问题：ASP.NET框架中是否已经存在这样的问题？

当然。它与ASP.NET没有特别的关系，但您可以查看System.Runtime.Caching命名空间，更具体地说是MemoryCache类。它在线程安全哈希表的顶部添加了过期和回调之类的东西。

我不太明白您在更新的答案中显示的AccountCache的目的。这正是一个简单的缓存层为您提供免费的。

显然，如果您打算在Web场中运行ASP.NET应用程序，则应考虑使用某些分布式缓存，例如memcached。在memcached协议之上有ObjectCache类的.NET实现。

Answer 2

我还想注意，我粗略地看了一下ConcurrentDictionary，看起来项目替换既不是单个项也不是整个字典，而是项目的哈希（即与之关联的锁定对象）字典“斗”）。它的设计似乎是为了在不需要调整字典大小的情况下，初始引入密钥也不会锁定整个字典。我相信这也意味着两个更新可以同时发生，只要它们不产生匹配的哈希值。

替换不同的ConcurrentDictionary键上的操作共享一个锁吗？

2 个答案: