Voorbij / voor I/O biedt .NET de voor — berekeningen uitvoeren over meerdere cores. Het cruciale onderscheid: / is voor I/O-concurrency (non-blocking waits), terwijl , en PLINQ voor het paralleliseren van CPU-intensief werk zijn.
Voorbij / voor I/O biedt .NET de voor — berekeningen uitvoeren over meerdere cores. Het cruciale onderscheid: / is voor I/O-concurrency (non-blocking waits), terwijl , en PLINQ voor het paralleliseren van CPU-intensief werk zijn.
asyncawaitasyncawaitTask.RunParallelasync/await → I/O-bound concurrency. Frees the thread during waits (DB, network).
Does NOT add CPU parallelism.
Parallelism → CPU-bound work spread across MULTIPLE CORES (computation, processing).
Use 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 werk in op een thread pool thread — gebruik het om CPU-bound berekeningen te paralleliseren (NIET voor I/O, waar async/await al volstaat zonder extra threads).
// 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 en PLINQ (.AsParallel()) verdelen werk automatisch over cores — ideaal voor CPU-intensieve verwerking van onafhankelijke items. (Alleen de moeite waard voor echt CPU-bound werk met aanzienlijke omvang — er is 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
Het begrijpen van Tasks en parallelisme voorbij async/await is belangrijke kennis op senior-niveau voor het bouwen van performante C#-toepassingen, en het cruciale onderscheid tussen I/O-concurrency en CPU-parallelisme is het kernidee — een veelvoorkomend verwarmingspunt. async/await behandelt I/O-bound concurrency (threads vrijmaken tijdens waits), maar voegt geen CPU-parallelisme toe, terwijl CPU-bound werk (berekeningen, gegevensverwerking) profiteert van echt parallelisme over cores via Task.Run (CPU-werk offloaden naar thread pool threads), Parallel.For/ForEach en PLINQ (.AsParallel()).
Weten welk instrument past — async/await voor I/O, de TPL-parallelisme tools voor CPU-bound werk — is essentieel voor effectieve prestatie-optimalisatie, omdat het verkeerde gebruiken (bijv. verwachten dat async berekening versnelt, of threads starten voor I/O die async efficiënt afhandelt) ineffectief is.
Evenals belangrijk is het begrijpen van thread safety: parallelle code die gedeelde status benadert, heeft synchronisatie nodig (lock, Interlocked voor atomaire operaties of thread-safe collections zoals ConcurrentDictionary) om race conditions te voorkomen — een kritieke correctheid-kwestie in parallelle code.
Het begrijpen van het I/O-vs-CPU onderscheid, de parallelisme tools (Task.Run, Parallel, PLINQ) en thread-safety vereisten is waardevol voor het schrijven van correcte, performante concurrent en parallel C#.
Omdat moderne toepassingen vaak zowel I/O-concurrency als CPU-parallelisme nodig hebben, en omdat het kiezen van de juiste benadering en het correct afhandelen van thread safety is wat parallelle code effectief en correct maakt, is dit belangrijke, veelvuldig relevante senior-kennis voor performance-gevoelige C#-ontwikkeling.