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

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

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(...);
}

我能够使其工作，但这导致了一些难看的代码。我的问题是，是否有更好，更优雅的方法来实现线程安全字典？

正如Peter所说，您可以将所有线程安全性封装在类中。您需要谨慎对待公开或添加的任何事件，确保它们在任何锁之外都被调用。

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

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

在内部尝试进行同步几乎肯定是不够的，因为它的抽象级别太低。假设您将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一起去）

您不应该通过属性发布私有锁对象。锁定对象应仅作为一个集合点而私下存在。

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

您描述的实现方法存在几个问题。

1. 您不应该公开同步对象。这样做将使您对抓住物品并锁定它的消费者敞开大门，然后您就敬酒了。
2. 您正在使用线程安全类实现非线程安全接口。恕我直言，这将花费您一路走来

就个人而言，我发现实现线程安全类的最佳方法是通过不变性。它确实减少了线程安全可能遇到的问题。查看Eric Lippert的博客以获取更多详细信息。

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

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

您的情况如下：

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

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

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

例

    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);
    }

集合与同步