C# / .NET Kompendium PLEN
.NET / C# / Algorytmy, struktury danych

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.Delay w 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>.

Postaw mi kawę