async/ I/O-க்கு அப்பால், .NET -ஐ -க்காக வழங்குகிறது — பல cores-முழுவதும் கணக்கீடுகளை இயக்குதல். முக்கிய வேறுபாடு: / என்பது I/O concurrency-க்கு (non-blocking waits), , , மற்றும் PLINQ பொதுவாக CPU-intensive work-ஐ parallelization செய்வதற்குப் பயன்படுத்தப்படுகிறது.
awaitasyncawaitTask.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 work-ஐ thread pool thread-ல் அட்டவணைப்படுத்துகிறது — CPU-bound computation-ஐ parallelization செய்வதற்கு இதைப் பயன்படுத்தவும் (I/O-க்கு அல்ல, அங்கு async/await ஏற்கனவே அতিরிక்த 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 மற்றும் PLINQ (.AsParallel()) work-ஐ cores-முழுவதும் தானாகவே விநியோகம் செய்கிறது — CPU-heavy processing of independent items-க்கு சிறந்தது. (உண்மையான CPU-bound, sizeable work-க்கு மட்டுமே பயன்பாடு உண்டு — 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
Async/await-க்கு அப்பால் Tasks மற்றும் parallelism-ஐ புரிந்துகொள்ளுதல் performant C# applications-ஐ உருவாக்குவதற்கான முக்கியமான senior-level knowledge ஆகும், மற்றும் I/O concurrency மற்றும் CPU parallelism-க்கு இடையிலான முக்கிய வேறுபாடு என்பது மূல insight ஆகும் — இது confusion-ற்கு பொதுவான புள்ளி. async/await I/O-bound concurrency-ஐ கையாளுகிறது (waits-க்கு பொழுது threads-ஐ விடுவித்தல்) ஆனால் CPU parallelism-ஐ சேர்க்காது, அதேவேளை CPU-bound work (computations, data processing) Task.Run (CPU work-ஐ thread pool threads-க்கு அனுப்புதல்), Parallel.For/ForEach, மற்றும் PLINQ (.AsParallel()) வழியே cores-ல் நிஜமான parallelism-ից பயன்பெறுகிறது.
யாது அளவுக்கு பொருத்தமாக உள்ளது என்பதை அறிதல் — I/O-க்கு async/await, CPU-bound work-க்கு TPL parallelism tools — effective performance optimization-ற்கு அপরिহार्य ஆகும், wrong one-ஐ பயன்படுத்துதல் என்பது (e.g. async computation-ஐ வேகமாக்க எதிர்பார்ப்பது, அல்லது async திறமையாக கையாளும் I/O-ற்குப் threads உரு திறத்தல்) ineffective ஆகும்.
समान முக்கியமாக thread safety-ஐ புரிந்துகொள்ளுதல் ஆகும்: parallel code shared state-ஐ அணுகும் synchronization (lock, Interlocked atomic operations-ற்கு, அல்லது thread-safe collections such as ConcurrentDictionary) প் race conditions-ஐ தவிர்க்க — parallel code-ல் ஒரு critical correctness concern.
I/O-vs-CPU distinction-ஐ, parallelism tools-ஐ (Task.Run, Parallel, PLINQ), மற்றும் thread-safety requirements-ஐ புரிந்துகொள்ளுதல் correct, performant concurrent மற்றும் parallel C#-ஐ எழுத மதிப்புள்ளது.
आधुनिक applications பெரும்பாலும் I/O concurrency மற்றும் CPU parallelism இரண்டையுமே தேவைப்படுவதாலும், சரியான approach-ஐ தேர்ந்தெடுக்கப்பட்டு thread safety-ஐ சரியாக கையாளுவதுதான் parallel code-ஐ effective மற்றும் correct ஆக்குவது என்பதாலும், இந்தக் knowledge performance-sensitive C# development-ற்கு முக்கியமான, அடிக்கடி-relevant senior knowledge ஆகும்.