.NET - Блокировка словаря по сравнению с ConcurrentDictionary

Эти ConcurrentDictionary большая опция, если она выполняет весь Ваши потребности потокобезопасности. Если это не, другими словами, Вас делают что-либо немного сложное, нормальным Dictionary + lock может быть более оптимальный вариант. Например, позволяет, говорят, что Вы добавляете некоторые заказы в словарь, и Вы хотите держать общую сумму в курсе заказов. Можно написать код как это:

private ConcurrentDictionary<int, Order> _dict;
private Decimal _totalAmount = 0;

while (await enumerator.MoveNextAsync())
{
    Order order = enumerator.Current;
    _dict.TryAdd(order.Id, order);
    _totalAmount += order.Amount;
}

Этот код не ориентирован на многопотоковое исполнение. Несколько потоков, обновляющих _totalAmount поле, могут оставить его в поврежденном состоянии. Таким образом, можно попытаться защитить его с lock:

_dict.TryAdd(order.Id, order);
lock (_locker) _totalAmount += order.Amount;

Этот код "более безопасен", но все еще ориентирован на многопотоковое исполнение. Нет никакой гарантии, которая эти _totalAmount согласовывается с записями в словаре. Другой поток может попытаться считать эти значения, обновить элемент UI:

Decimal totalAmount;
lock (_locker) totalAmount = _totalAmount;
UpdateUI(_dict.Count, totalAmount);

Эти totalAmount может не соответствовать количеству заказов в словаре. Отображенная статистика могла быть неправильной. В этой точке Вы поймете, что необходимо расшириться lock защита для включения обновления словаря:

// Thread A
lock (_locker)
{
    _dict.TryAdd(order.Id, order);
    _totalAmount += order.Amount;
}

// Thread B
int ordersCount;
Decimal totalAmount;
lock (_locker)
{
    ordersCount = _dict.Count;
    totalAmount = _totalAmount;
}
UpdateUI(ordersCount, totalAmount);

Этот код совершенно безопасен, но всех преимуществ использования ConcurrentDictionary не стало.

1. производительность стала хуже, чем использование нормального Dictionary, потому что внутренняя блокировка в эти ConcurrentDictionary теперь расточительна и избыточна.
2. необходимо рассмотреть весь код для незащищенного использования совместно используемых переменных.
3. Вы застреваете с использованием неловкого API (TryAdd?, AddOrUpdate?).

, Таким образом, мой совет: запустите с Dictionary + lock и сохраните опцию обновления позже до ConcurrentDictionary как оптимизация производительности, если этот вариант на самом деле жизнеспособен. Во многих случаях это не будет.

Вам все равно нужно быть очень осторожным при использовании поточно-ориентированных коллекций, потому что поточно-ориентированные коллекции не означают, что вы можете игнорировать все проблемы с потоками. Когда коллекция объявляет себя поточно-ориентированной, это обычно означает, что она остается в согласованном состоянии, даже когда несколько потоков одновременно читают и записывают. Но это не означает, что один поток увидит «логическую» последовательность результатов, если вызовет несколько методов.

Например, если вы сначала проверяете, существует ли ключ, а затем получаете значение, соответствующее этому ключу, этот ключ может больше не существовать даже с версией ConcurrentDictionary (потому что другой поток мог удалить ключ). В этом случае вам все равно нужно использовать блокировку (или лучше: объединить два вызова, используя TryGetValue ).

Так что используйте их, но не Не думаю, что это дает вам возможность игнорировать все проблемы параллелизма. Вам по-прежнему нужно быть осторожным.

По сути, вы хотите использовать новый ConcurrentDictionary. Сразу после установки вам нужно писать меньше кода, чтобы сделать программы потокобезопасными.

Я думаю, что метод ConcurrentDictionary.GetOrAdd - это именно то, что нужно большинству многопоточных сценариев

] Видели ли вы [] реактивные расширения [] для .Net 3.5sp1. По словам Джона Скита (Jon Skeet), для .Net 3.5 sp1 они сообщили о пакете параллельных расширений и параллельных структурах данных.[

]Существует набор примеров для .Net 4 Beta 2, в котором довольно подробно описано, как использовать их параллельные расширения. [

]Я только что провел последнюю неделю, тестируя ConcurrentDictionary, используя 32 потока для выполнения ввода/вывода. Похоже, что он работает так, как рекламируется, что говорит о том, что в него было вложено огромное количество тестов. [

][]Правка []: .NET 4 ConcurrentDictionary и паттерны. [

]Microsoft выпустила pdf под названием Patterns of Paralell Programming. Его стоит скачать, так как в нем очень подробно описаны правильные шаблоны для .Net 4 ConcurrentDictionary и анти-шаблоны, которых следует избегать. []Вот оно.[][