实现线程安全字典的最佳方法是什么？

Question

通过从 IDictionary 派生并定义私有 SyncRoot 对象，我能够在 C# 中实现线程安全字典：

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue>
{
    private readonly object syncRoot = new object();
    private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();

    public object SyncRoot
    {
        get { return syncRoot; }
    } 

    public void Add(TKey key, TValue value)
    {
        lock (syncRoot)
        {
            d.Add(key, value);
        }
    }

    // more IDictionary members...
}

然后我在整个消费者（多个线程）中锁定这个 SyncRoot 对象：

例子：

lock (m_MySharedDictionary.SyncRoot)
{
    m_MySharedDictionary.Add(...);
}

我能够让它工作，但这导致了一些丑陋的代码。我的问题是，有没有更好、更优雅的方式来实现线程安全字典？

Answer 1

尝试在内部进行同步几乎肯定是不够的，因为它的抽象级别太低了。假设您将 Add 和 ContainsKey 操作分别设置为线程安全的，如下所示：

public void Add(TKey key, TValue value)
{
    lock (this.syncRoot)
    {
        this.innerDictionary.Add(key, value);
    }
}

public bool ContainsKey(TKey key)
{
    lock (this.syncRoot)
    {
        return this.innerDictionary.ContainsKey(key);
    }
}

那么当你从多个线程调用这段所谓的线程安全的代码时会发生什么？它总是可以正常工作吗？

if (!mySafeDictionary.ContainsKey(someKey))
{
    mySafeDictionary.Add(someKey, someValue);
}

简单的答案是否定的。在某些时候，Add 方法会抛出一个异常，表明该键已经存在于字典中。你可能会问，这怎么可能是线程安全的字典？好吧，因为每个操作都是线程安全的，所以两个操作的组合不是，因为另一个线程可以在您调用 ContainsKey 和 Add 之间修改它。

这意味着要正确编写这种类型的场景，您需要在字典之外 加一个锁，例如

lock (mySafeDictionary)
{
    if (!mySafeDictionary.ContainsKey(someKey))
    {
        mySafeDictionary.Add(someKey, someValue);
    }
}

但是现在，由于您必须编写外部锁定代码，因此您将内部和外部同步混为一谈，这总是会导致代码不清晰和死锁等问题。所以最终你可能会更好：

1. 使用普通的Dictionary<TKey, TValue> 并在外部同步，将复合操作封装在其上，或者

2. 编写一个新的线程安全包装器，它具有不同的接口（即不是IDictionary<T>），它结合了AddIfNotContained 方法等操作，因此您永远不需要结合它的操作。

（我自己倾向于选择#1）

Answer 2

支持并发的 .NET 4.0 类被命名为ConcurrentDictionary。

Answer 3

你描述的实现方法有几个问题。

1. 您永远不应该公开您的同步对象。这样做会向消费者敞开心扉，抓住物体并锁定它，然后你就完蛋了。
2. 您正在使用线程安全类实现非线程安全接口。恕我直言，这会让你付出代价

就我个人而言，我发现实现线程安全类的最佳方式是通过不变性。它确实减少了线程安全可能遇到的问题。查看Eric Lippert's Blog 了解更多详情。

Answer 4

您无需在使用者对象中锁定 SyncRoot 属性。您在字典方法中拥有的锁就足够了。

详细说明： 最终发生的是您的字典被锁定的时间超过了必要的时间。

您的情况如下：

假设线程 A 在调用 m_mySharedDictionary.Add 之前获得了 SyncRoot 上的锁。然后线程 B 尝试获取锁但被阻塞。事实上，所有其他线程都被阻塞了。允许线程 A 调用 Add 方法。在 Add 方法中的 lock 语句中，允许线程 A 再次获得锁，因为它已经拥有它。在方法内退出锁上下文，然后在方法外，线程 A 已释放所有锁，允许其他线程继续。

您可以简单地允许任何使用者调用 Add 方法，因为 SharedDictionary 类 Add 方法中的 lock 语句将具有相同的效果。此时，您有冗余锁定。如果您必须对需要保证连续发生的字典对象执行两个操作，则只能在字典方法之一之外锁定 SyncRoot。

Answer 5

正如彼得所说，您可以将所有线程安全封装在类中。您需要小心您公开或添加的任何事件，确保它们在任何锁之外被调用。

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue>
{
    private readonly object syncRoot = new object();
    private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();

    public void Add(TKey key, TValue value)
    {
        lock (syncRoot)
        {
            d.Add(key, value);
        }
        OnItemAdded(EventArgs.Empty);
    }

    public event EventHandler ItemAdded;

    protected virtual void OnItemAdded(EventArgs e)
    {
        EventHandler handler = ItemAdded;
        if (handler != null)
            handler(this, e);
    }

    // more IDictionary members...
}

编辑： MSDN 文档指出枚举本质上不是线程安全的。这可能是在类之外公开同步对象的原因之一。另一种方法是提供一些方法来对所有成员执行操作并锁定成员的枚举。这样做的问题是您不知道传递给该函数的操作是否调用了字典的某些成员（这将导致死锁）。公开同步对象允许消费者做出这些决定，并且不会隐藏类中的死锁。

Answer 6

Collections And Synchronization

Answer 7

您不应该通过属性发布您的私有锁对象。锁定对象应该私下存在，唯一的目的是充当集合点。

如果证明使用标准锁的性能很差，那么 Wintellect 的 Power Threading 锁集合会非常有用。

Answer 8

只是一个想法，为什么不重新创建字典？如果读取是大量写入，那么锁定将同步所有请求。

例子

    private static readonly object Lock = new object();
    private static Dictionary<string, string> _dict = new Dictionary<string, string>();

    private string Fetch(string key)
    {
        lock (Lock)
        {
            string returnValue;
            if (_dict.TryGetValue(key, out returnValue))
                return returnValue;

            returnValue = "find the new value";
            _dict = new Dictionary<string, string>(_dict) { { key, returnValue } };

            return returnValue;
        }
    }

    public string GetValue(key)
    {
        string returnValue;

        return _dict.TryGetValue(key, out returnValue)? returnValue : Fetch(key);
    }