ConcurrentQueue<T>
Co to jest
ConcurrentQueue<T> to kolejka FIFO (first-in-first-out) z przestrzeni nazw System.Collections.Concurrent, zaprojektowana do bezpiecznego użycia z wielu wątków bez jawnego blokowania (lock).
var queue = new ConcurrentQueue<string>();
queue.Enqueue("pierwszy");
queue.Enqueue("drugi");
if (queue.TryDequeue(out var item))
{
Console.WriteLine(item); // "pierwszy"
}
Czym różni się od Queue<T> + lock
Zwykłe Queue<T> nie jest thread-safe — jeśli dwa wątki wywołają Enqueue/Dequeue równocześnie, struktura wewnętrzna może się uszkodzić. Klasyczne rozwiązanie to własny lock:
private readonly Queue<string> _queue = new();
private readonly object _lock = new();
public void Enqueue(string item)
{
lock (_lock) { _queue.Enqueue(item); }
}
public bool TryDequeue(out string? item)
{
lock (_lock) { return _queue.TryDequeue(out item); }
}
To działa, ale lock oznacza, że tylko jeden wątek na raz może wykonywać operację — pozostałe czekają (blokują się), co pod dużym obciążeniem generuje narzut kontekstowy (wątek usypiany i wznawiany przez system operacyjny).
ConcurrentQueue<T> jest lock-free — wewnętrznie wykorzystuje operacje atomowe procesora (Interlocked.CompareExchange i podobne), żeby bezpiecznie modyfikować strukturę bez blokowania całego dostępu. W praktyce wiele wątków może próbować równocześnie, a te, którym się "nie uda" w danej chwili, po prostu ponawiają operację (spin + retry), zamiast czekać w kolejce do monitora jak przy lock. Dla scenariuszy z dużą konkurencją to zazwyczaj zauważalnie szybsze.
Dlaczego TryDequeue/TryPeek, a nie Dequeue/Peek
ConcurrentQueue<T> nie ma zwykłych metod Dequeue()/Peek(), które rzucają wyjątek, gdy kolekcja jest pusta — ma tylko wariant Try*:
bool TryDequeue(out T result);
bool TryPeek(out T result);
Powód: w środowisku wielowątkowym sprawdzenie "czy kolekcja jest pusta" (IsEmpty) i następujące po nim pobranie elementu to dwie odrębne operacje. Między nimi inny wątek może dodać albo zabrać element — klasyczny wyścig (race condition, TOCTOU — "time-of-check to time-of-use"). Wzorzec Try* łączy "sprawdź i pobierz" w jedną atomową operację, eliminując to okno na błąd.
// ŹLE - wyścig między IsEmpty i Dequeue
if (!queue.IsEmpty)
{
var item = queue.Dequeue(); // tej metody nawet nie ma, i dobrze
}
// DOBRZE - atomowo
if (queue.TryDequeue(out var item))
{
Use(item);
}
Przykład: producent-konsument (background log processor)
Typowy use case: wiele wątków dorzuca zadania/logi do kolejki (producenci), a jeden wątek w tle odczytuje je i przetwarza (konsument) — bez blokowania producentów.
public class BackgroundLogProcessor
{
private readonly ConcurrentQueue<string> _logQueue = new();
private readonly CancellationTokenSource _cts = new();
public void Enqueue(string message) => _logQueue.Enqueue(message);
public Task StartProcessingAsync()
{
return Task.Run(async () =>
{
while (!_cts.Token.IsCancellationRequested)
{
if (_logQueue.TryDequeue(out var message))
{
await WriteToFileAsync(message);
}
else
{
await Task.Delay(50); // nic do roboty - odczekaj chwilę
}
}
});
}
private Task WriteToFileAsync(string message) =>
File.AppendAllTextAsync("log.txt", message + "\n");
public void Stop() => _cts.Cancel();
}
Dowolna liczba wątków może wołać Enqueue równocześnie (np. z różnych requestów HTTP), a jeden wątek w tle spokojnie je konsumuje — bez lock, bez ryzyka zablokowania wątków producentów.
A co z Channel<T>?
Nowszym, często lepszym narzędziem do wzorca producent-konsument jest System.Threading.Channels.Channel<T> (od .NET Core 3.0):
ConcurrentQueue<T>— synchroniczna struktura danych; jeśli konsument chce "czekać" na nowy element bez pollingu (Task.Delayw pętli), musi to sam zaimplementować.Channel<T>— ma natywne wsparcie async (await reader.ReadAsync(), który realnie zawiesza się do pojawienia się elementu, bez pollingu) oraz backpressure (ograniczenie rozmiaru bufora z blokowaniem/odrzucaniem producenta, gdy jest pełny).
W nowym kodzie do komunikacji producent-konsument często wybiera się Channel<T>; ConcurrentQueue<T> nadal świetnie się sprawdza jako prosty, współdzielony bufor bez potrzeby natywnego await-owania na nowe elementy.
Rodzina System.Collections.Concurrent
| Typ | Struktura | Odpowiednik niethread-safe |
|---|---|---|
ConcurrentQueue<T> |
FIFO | Queue<T> |
ConcurrentStack<T> |
LIFO | Stack<T> |
ConcurrentDictionary<TKey, TValue> |
mapa klucz-wartość | Dictionary<TKey, TValue> |
ConcurrentBag<T> |
nieuporządkowany zbiór, zoptymalizowany pod ten sam wątek dodaje i zabiera | — |
Wszystkie są lock-free (lub prawie — ConcurrentDictionary w niektórych operacjach stosuje drobnoziarniste blokady wewnętrzne), i wszystkie udostępniają wzorzec Try* z tego samego powodu co ConcurrentQueue<T>.