スレッドセーフな辞書を実装する最良の方法は何ですか？

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

私はそれを動作させることができましたが、これはいくつかの醜いコードをもたらしました。私の質問は、スレッドセーフな辞書を実装するより良い、よりエレガントな方法はありますか？

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ドキュメントは、列挙は本質的にスレッドセーフではないことを指摘しています。これが、クラスの外部で同期オブジェクトを公開する理由の1つになる可能性があります。これにアプローチする別の方法は、すべてのメンバーに対してアクションを実行するためのいくつかのメソッドを提供し、メンバーの列挙をロックすることです。この問題は、その関数に渡されたアクションがディクショナリの一部のメンバーを呼び出すかどうかがわからないことです（デッドロックが発生します）。同期オブジェクトを公開することで、コンシューマはそれらの決定を行うことができ、クラス内のデッドロックを隠蔽しません。

同時実行性をサポートする.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. スレッドセーフクラスを使用して非スレッドセーフインターフェイスを実装しています。私見これはあなたが道を行くコストがかかります

個人的には、スレッドセーフクラスを実装する最良の方法は、不変性による方法です。スレッドセーフで発生する可能性のある問題の数を本当に減らします。チェックアウトエリックリペットのブログを詳細については。

コンシューマオブジェクトのSyncRootプロパティをロックする必要はありません。辞書のメソッド内にあるロックで十分です。

詳しく説明するには： 何が起こっているのかというと、辞書が必要以上に長い時間ロックされているということです。

あなたのケースで何が起こるかは次のとおりです：

スレッドAがSyncRootのロックを取得するとします 前に m_mySharedDictionary.Addを呼び出すするとします。その後、スレッドBはロックの取得を試みますが、ブロックされます。実際、他のすべてのスレッドはブロックされています。スレッドAはAddメソッドを呼び出すことができます。Addメソッド内のロックステートメントでは、スレッドAは既にロックを所有しているため、再度ロックを取得できます。メソッド内でロックコンテキストを終了し、メソッドの外で、スレッドAがすべてのロックを解放し、他のスレッドが続行できるようにしました。

SharedDictionaryクラスのAddメソッド内のlockステートメントが同じ効果を持つので、任意のコンシューマーがAddメソッドを呼び出せるようにするだけです。この時点で、ロックが重複しています。連続して発生することが保証される必要のあるディクショナリオブジェクトに対して2つの操作を実行する必要がある場合にのみ、ディクショナリメソッドの1つの外で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);
    }

コレクションと同期