Kolekcje współbieżne#
Przestrzeń nazw System.Collections.Concurrent zawiera kolekcje zoptymalizowane pod kątem dostępu wielowątkowego. W przeciwieństwie do standardowych kolekcji (np. List<T>, Dictionary<TKey, TValue>), które wymagają ręcznego blokowania (np. przez lock) przy każdym dostępie, kolekcje współbieżne radzą sobie z synchronizacją wewnętrznie, często używając technik lock-free lub precyzyjnego blokowania (fine-grained locking).
Standardowe kolekcje są wydajniejsze od kolekcji współbieżnych w sytuacjach, gdzie nie ma współbieżności.
Kolekcje#
ConcurrentDictionary<TKey, TValue>: Bezpieczny wątkowo słownik. Pozwala na jednoczesny odczyt i zapis przez wiele wątków bez blokowania całego słownika.- Metody:
TryAdd,TryUpdate,GetOrAdd,AddOrUpdate.
- Metody:
ConcurrentQueue<T>: Bezpieczna kolejka FIFO.ConcurrentStack<T>: Bezpieczny stos LIFO.ConcurrentBag<T>: Nieuporządkowany multizbiór elementów.
Iteracja po współbieżnej kolekcji podczas równoczesnej modyfikacji przez inny wątek nigdy nie kończy się rzuceniem wyjątku. Enumeratory
ConcurrentQueue<T>,ConcurrentStack<T>iConcurrentBag<T>działają na migawce (snapshot) wykonanej w chwili rozpoczęcia iteracji, natomiast iteracja poConcurrentDictionary<TKey, TValue>nie jest migawką - może zawierać zarówno już usunięte, jak i nowo dodane wartości.
Wewnętrznie
ConcurrentStack<T>jest listą jednokierunkową, aConcurrentQueue<T>- listą segmentów tablicowych. WConcurrentBag<T>każdy wątek otrzymuje swoją własną prywatną kolejkę lokalną, dzięki czemu dodawanie i pobieranie elementów jest bardzo szybkie i odbywa się bez rywalizacji, pod warunkiem że wątek nie pobiera więcej elementów, niż włożył (w przeciwnym razie musi “podkradać” elementy z kolejek innych wątków).
IProducerConsumerCollection#
IProducerConsumerCollection<T> to interfejs w przestrzeni nazw System.Collections.Concurrent, który definiuje kontrakt dla kolekcji bezpiecznych wątkowo, przeznaczonych do scenariuszy typu Producent-Konsument.
public interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection
{
void CopyTo(T[] array, int index);
bool TryAdd(T item);
bool TryTake(out T item);
T[] ToArray();
}Jest on implementowany przez ConcurrentQueue<T>, ConcurrentStack<T> oraz ConcurrentBag<T>.
BlockingCollection#
BlockingCollection<T> to specjalna klasa, która implementuje klasyczny wzorzec Producent-Konsument. Opakowuje ona inną kolekcję współbieżną implementującą IProducerConsumerCollection<T> (domyślnie ConcurrentQueue<T>) i dodaje mechanizmy blokowania:
- Producent: Jeśli kolekcja ma ograniczoną pojemność, metoda
Addzablokuje wątek producenta, jeśli kolekcja jest pełna. - Konsument: Metoda
Takezablokuje wątek konsumenta, jeśli kolekcja jest pusta, czekając na pojawienie się elementu.
Przykład#
W poniższym przykładzie producent dodaje liczby do kolekcji, a konsument je pobiera. Dzięki GetConsumingEnumerable(), konsument może łatwo iterować po elementach aż do momentu, gdy producent zgłosi zakończenie dodawania (CompleteAdding), a wszystkie pozostałe elementy zostaną pobrane.
var blockingCollection = new BlockingCollection<int>(boundedCapacity: 5);
Task producer = Task.Run(() =>
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine($"Producing: {i}");
blockingCollection.Add(i); // Can block if full
Thread.Sleep(500);
}
blockingCollection.CompleteAdding(); // Signal end of data
});
Task consumer = Task.Run(() =>
{
foreach (var item in blockingCollection.GetConsumingEnumerable())
{
Console.WriteLine($"Consuming: {item}");
Thread.Sleep(1000);
}
});
Task.WaitAll(producer, consumer);Kod źródłowy:
Kanały (Channels)#
Przestrzeń nazw System.Threading.Channels (wbudowana w .NET od wersji .NET Core 3.0) udostępnia Channel<T> - nowoczesną, asynchroniczną alternatywę dla BlockingCollection<T>. Kanał ma dwa końce: Writer (ChannelWriter<T>), z którego korzystają producenci, oraz Reader (ChannelReader<T>), z którego korzystają konsumenci. Zamiast blokować wątki, obie strony czekają asynchronicznie:
- Producent:
WriteAsyncczeka (await), jeśli kanał o ograniczonej pojemności (Channel.CreateBounded<T>) jest pełny.Channel.CreateUnbounded<T>()tworzy kanał bez limitu pojemności. - Konsument:
ReadAsyncczeka na pojawienie się elementu.ReadAllAsync()zwraca asynchroniczną sekwencję (IAsyncEnumerable<T>), która kończy się, gdy producent wywołaWriter.Complete(), a wszystkie pozostałe elementy zostaną odczytane.
Przykład#
Poprzedni przykład przepisany z użyciem kanału:
var channel = Channel.CreateBounded<int>(capacity: 5);
Task producer = Task.Run(async () =>
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine($"Producing: {i}");
await channel.Writer.WriteAsync(i); // Waits asynchronously if full
await Task.Delay(500);
}
channel.Writer.Complete(); // Signal end of data
});
Task consumer = Task.Run(async () =>
{
await foreach (var item in channel.Reader.ReadAllAsync())
{
Console.WriteLine($"Consuming: {item}");
await Task.Delay(1000);
}
});
await Task.WhenAll(producer, consumer);W nowym kodzie, zwłaszcza asynchronicznym, warto wybierać
Channel<T>zamiastBlockingCollection<T>- oczekiwanie nie blokuje wątków z puli. Kanały o ograniczonej pojemności można też skonfigurować (BoundedChannelOptions.FullMode) tak, aby zamiast czekać, odrzucały najstarszy lub najnowszy element, a opcjeSingleReader/SingleWriterpozwalają użyć szybszych implementacji.
Kod źródłowy: