Über / für I/O hinaus stellt .NET die für bereit — also das Ausführen von Berechnungen über mehrere Kerne hinweg. Der entscheidende Unterschied: / ist für I/O-Nebenläufigkeit gedacht (nicht blockierendes Warten), während , und PLINQ dazu dienen, CPU-intensive Arbeit zu parallelisieren.
asyncawaitasyncawaitTask.RunParallelasync/await → I/O-gebundene Nebenläufigkeit. Gibt den Thread während des Wartens frei (DB, Netzwerk).
Fügt KEINE CPU-Parallelität hinzu.
Parallelität → CPU-gebundene Arbeit verteilt auf MEHRERE KERNE (Berechnung, Verarbeitung).
Verwende Task.Run, Parallel.For/ForEach, PLINQ.
// run a CPU-intensive computation on a thread pool thread (don't block the caller)
int result = await Task.Run(() => ExpensiveComputation());
// run multiple in parallel and combine
var tasks = items.Select(item => Task.Run(() => Process(item)));
var results = await Task.WhenAll(tasks); // wait for all
Task.Run plant Arbeit auf einem Thread-Pool-Thread ein — verwende es, um CPU-gebundene Berechnungen zu parallelisieren (NICHT für I/O, wo async/await bereits ohne zusätzliche Threads ausreicht).
// Parallel.For/ForEach — process a collection across cores
Parallel.ForEach(items, item => Process(item)); // automatically uses multiple cores
Parallel.For(0, 1000, i => Compute(i));
// PLINQ — parallel LINQ
var results = data.AsParallel().Where(x => IsValid(x)).Select(Transform).ToList();
Parallel.For/ForEach und PLINQ (.AsParallel()) verteilen die Arbeit automatisch auf die Kerne — ideal für CPU-intensive Verarbeitung unabhängiger Elemente. (Nur lohnenswert für wirklich CPU-gebundene, umfangreiche Arbeit — es entsteht Overhead.)
// parallel code accessing SHARED state needs synchronization or thread-safe types
lock (_lock) { _counter++; } // lock for mutual exclusion
Interlocked.Increment(ref _counter); // lock-free atomic
var dict = new ConcurrentDictionary<string, int>(); // thread-safe collection
Tasks und Parallelität über async/await hinaus zu verstehen, ist wichtiges Senior-Level-Wissen für den Bau performanter C#-Anwendungen, und die entscheidende Unterscheidung zwischen I/O-Nebenläufigkeit und CPU-Parallelität ist die zentrale Erkenntnis — ein häufiger Punkt der Verwirrung. async/await behandelt I/O-gebundene Nebenläufigkeit (gibt Threads während des Wartens frei), fügt aber keine CPU-Parallelität hinzu, wohingegen CPU-gebundene Arbeit (Berechnungen, Datenverarbeitung) von echter Parallelität über mehrere Kerne profitiert — via Task.Run (Auslagern von CPU-Arbeit auf Thread-Pool-Threads), Parallel.For/ForEach und PLINQ (.AsParallel()).
Zu wissen, welches Werkzeug passt — async/await für I/O, die TPL-Parallelitätswerkzeuge für CPU-gebundene Arbeit — ist entscheidend für eine effektive Performance-Optimierung, da der Einsatz des falschen Werkzeugs (z. B. zu erwarten, dass async eine Berechnung beschleunigt, oder Threads für I/O zu starten, das async effizient handhabt) wirkungslos ist.
Ebenso wichtig ist das Verständnis von Thread-Sicherheit: Paralleler Code, der auf gemeinsam genutzten Zustand zugreift, benötigt Synchronisation (lock, Interlocked für atomare Operationen oder thread-sichere Collections wie ConcurrentDictionary), um Race Conditions zu vermeiden — ein kritischer Korrektheitsaspekt in parallelem Code.
Die Unterscheidung zwischen I/O und CPU, die Parallelitätswerkzeuge (Task.Run, Parallel, PLINQ) und die Anforderungen an die Thread-Sicherheit zu verstehen, ist wertvoll, um korrektes und performantes nebenläufiges sowie paralleles C# zu schreiben.
Da moderne Anwendungen oft sowohl I/O-Nebenläufigkeit als auch CPU-Parallelität benötigen und da die Wahl des richtigen Ansatzes sowie der korrekte Umgang mit Thread-Sicherheit das sind, was parallelen Code effektiv und korrekt machen, ist dies wichtiges, häufig relevantes Senior-Wissen für performance-sensitive C#-Entwicklung.