I/O కోసం / కంటే ఆगળానికి, .NET ను కోసం అందించేది — బహుళ కోర్ల్లో గణనలను నడుపుతుంది. ముఖ్య వ్యత్యాసం: / I/O సమ్మతికి (నాన్-బ్లాకింగ్ వేచి ఉండటానికి) ఉపయోగించబడుతుంది, అయితే , , మరియు PLINQ CPU-సघన పనిని సమాంతరంగా నిర్వహించడానికి ఉపయోగించబడతాయి.
I/O కోసం / కంటే ఆगળానికి, .NET ను కోసం అందించేది — బహుళ కోర్ల్లో గణనలను నడుపుతుంది. ముఖ్య వ్యత్యాసం: / I/O సమ్మతికి (నాన్-బ్లాకింగ్ వేచి ఉండటానికి) ఉపయోగించబడుతుంది, అయితే , , మరియు PLINQ CPU-సघన పనిని సమాంతరంగా నిర్వహించడానికి ఉపయోగించబడతాయి.
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 థ్రెడ్ పూల్ థ్రెడ్లో పనిని షెడ్యూల్ చేస్తుంది — CPU-bound గణనను సమాంతరంగా నిర్వహించడానికి దీన్ని ఉపయోగించండి (I/O కోసం కాదు, అక్కడ async/await ఇప్పటికే అదనపు థ్రెడ్ల లేకుండా సరిపోతుంది).
// 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 మరియు PLINQ (.AsParallel()) కోర్ల్లో పనిని స్వయంచాలకంగా పంపిణీ చేస్తాయి — CPU-heavy స్వతంత్ర అంశాల ప్రసంస్కరణకు గ్రేట్. (నిజమైన CPU-bound, గణనీయమైన పనికి మాత్రమే విలువైనది — ఓవర్హెడ్ ఉంది.)
// 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
async/await కంటే ఆగళానికి Tasks మరియు parallelism గురించి అర్థం చేసుకోవడం సీనియర్-స్థర నాలెჯ్ ప్రదర్శక C# అప్లికేషన్లను నిర్మించడానికి, మరియు I/O సమ్మతి మరియు CPU parallelism మధ్య నిర్ణయాత్మక వ్యత్యాసం ముఖ్య అంతర్దృష్టి — గందరగోళం యొక్క సాధారణ పాయింట్. async/await I/O-bound సమ్మతిని నిర్వహిస్తుంది (వేచి ఉండటం సమయంలో థ్రెడ్లను విడుదల చేస్తుంది) కానీ CPU parallelism చేర్చదు, అయితే CPU-bound పనిలు (గణనలు, డేటా ప్రసంస్కరణ) Task.Run (CPU పనిని థ్రెడ్ పూల్ థ్రెడ్లకు బదిలీ చేస్తుంది), Parallel.For/ForEach, మరియు PLINQ (.AsParallel()) ద్వారా కోర్ల్లో నిజమైన parallelism నుండి ప్రయోజనం పొందుతాయి.
ఏ సాధనం సరిపోతుందో తెలుసుకోవడం — I/O కోసం async/await, CPU-bound పనికోసం TPL parallelism సాధనాలు — సమర్థవంతమైన పనితీరు ఆప్టిమైజేషన్ కోసం ముఖ్యమైనది, ఎందుకంటే తప్పుగా ఉపయోగించటం (ఉదా. గణనను వేగవంతం చేయడానికి async ఆశించటం, లేదా I/O కోసం థ్రెడ్లను తిప్పుటరు కోసం async సమర్థవంతంగా నిర్వహిస్తుంది) అసమర్థమైనది.
సమానంగా ముఖ్యమైనది థ్రెడ్ safety గురించి అర్థం చేసుకోవడం: భాగస్వామ్య స్థితిని యాక్సెస్ చేసే సమాంతర కోడ్ సమన్వయం (lock, Interlocked పరమాణువు కార్యకలాపాల కోసం, లేదా ConcurrentDictionary వంటి థ్రెడ్-సేఫ్ సంগ్రహాలు) రేస్ పరిస్థితులను నివారించడానికి అవసరమైనది — సమాంతర కోడ్లో విమర్శనీయ సరిదిద్దటం సమస్య.
I/O-vs-CPU వ్యత్యాసం, parallelism సాధనాలు (Task.Run, Parallel, PLINQ), మరియు థ్రెడ్-safety అవసరాల గురించి అర్థం చేసుకోవడం సరిగ్గా, పనితీరు సమాంతర C# వ్రాయడం కోసం విలువైనది.
ఆధునిక అప్లికేషన్లకు తరచుగా I/O సమ్మతి మరియు CPU parallelism రెండూ అవసరం కాబట్టి, మరియు సరైన విధానం ఎంచుకోవడం మరియు థ్రెడ్ safety సరిగ్గా నిర్వహించడం సమాంతర కోడ్ను సమర్థవంతమైనదిగా మరియు సరిగ్గా చేసే విషయాలు కాబట్టి, ఇది పనితీరు-సున్నితమైన C# డేవలప్మెంట్ కోసం ముఖ్యమైన, తరచుగా-సంబంధితమైన సీనియర్ నాలెჱ.