ConcurrentDictionary, ConcurrentQueue, ImmutableDictionary — когда что?

#Почему обычные коллекции небезопасны

Dictionary<K,V> при одновременной записи из нескольких потоков может не просто потерять данные, а испортить внутреннюю структуру: во время перестроения (resize) другой поток видит частично перенесённые бакеты. Известный симптом — бесконечный цикл в FindEntry и 100% загрузка CPU.

#ConcurrentDictionary

#Как устроен

• Каждый замок защищает группу бакетов; число замков по умолчанию ≈ числу ядер.
• Запись в разные сегменты идёт параллельно.
• Чтение (TryGetValue, индексатор) вообще не берёт блокировок.
• Операции над всем словарём (Count, Keys, Values, ToArray, resize) захватывают все замки — они дорогие. Не вызывайте Count в горячем цикле.

#Атомарные операции

var cache = new ConcurrentDictionary<int, Product>();

// Получить или добавить
Product p = cache.GetOrAdd(id, key => LoadProduct(key));

// Добавить или обновить
var hits = new ConcurrentDictionary<string, int>();
hits.AddOrUpdate(url, addValue: 1, updateValueFactory: (key, old) => old + 1);

// Условное обновление (CAS)
cache.TryUpdate(id, newValue: updated, comparisonValue: current);

// Удалить только если значение совпадает (.NET 5+)
cache.TryRemove(new KeyValuePair<int, Product>(id, stale));

Передача состояния без замыканий (без аллокаций на каждый вызов):

cache.GetOrAdd(key, static (k, repo) => repo.Load(k), _repository);

#ConcurrentQueue и Channel

var queue = new ConcurrentQueue<Job>();
queue.Enqueue(job);                           // производитель
if (queue.TryDequeue(out var next)) Run(next); // потребитель: нужно опрашивать в цикле

Проблема: потребителю нечего делать, когда очередь пуста — приходится крутиться в цикле или спать. Channel<T> решает это асинхронным ожиданием и поддерживает ограничение размера (backpressure):

var channel = Channel.CreateBounded<Job>(capacity: 1000);
await channel.Writer.WriteAsync(job, ct);                  // ждёт, если канал полон
await foreach (var j in channel.Reader.ReadAllAsync(ct))   // ждёт без блокировки, если пуст
    await RunAsync(j);

#Immutable-коллекции

ImmutableList<string> v1 = ImmutableList.Create("a", "b");
ImmutableList<string> v2 = v1.Add("c");      // v1 не изменился: ["a","b"], v2: ["a","b","c"]

• Внутри — сбалансированные деревья (AVL), поэтому чтение O(log n), а не O(1).
• Поток, получивший ссылку на коллекцию, работает со стабильным снапшотом — никаких «collection was modified».
• Для массовых изменений используйте Builder: var b = list.ToBuilder(); ... ; list = b.ToImmutable();.
• ImmutableArray<T> — обёртка над массивом: быстрое чтение, но каждое изменение копирует весь массив.

#Типичный паттерн: атомарная замена снапшота

private ImmutableDictionary<string, Route> _routes = ImmutableDictionary<string, Route>.Empty;

public Route? Find(string path) => _routes.GetValueOrDefault(path);    // читатели без блокировок

public void AddRoute(string path, Route route) =>
    ImmutableInterlocked.AddOrUpdate(ref _routes, path, route, (_, _) => route);  // CAS-цикл внутри

#FrozenDictionary (.NET 8+)

private static readonly FrozenDictionary<string, CountryInfo> Countries =
    LoadCountries().ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

var uz = Countries["UZ"];   // быстрее Dictionary: структура оптимизирована под конкретный набор ключей

При создании анализирует ключи и выбирает оптимальную стратегию хэширования (например, по длине строк или подстроке). Создание дорогое — только для данных, которые строятся один раз.

#Сравнение

#Вопросы на засыпку

#Итог

Изменяемые общие данные по ключу — ConcurrentDictionary (помните про многократный вызов фабрики и неатомарность составных операций). Очереди с ожиданием — Channel<T>. Редко меняющиеся данные — неизменяемые снапшоты (Immutable*), а справочники «на всю жизнь» — FrozenDictionary.