I/O ਲਈ / ਤੋਂ ਪਰੇ, .NET ਫਰਾਹਮ ਕਰਦਾ ਹੈ ਲਈ — ਕੰਪਿਊਟੇਸ਼ਨ ਨੂੰ ਮਲਟੀਪਲ ਕੋਰਸ ਦੇ ਪਾਰ ਚਲਾਉਂਦੇ ਹੋਏ। ਮੁੱਖ ਫ਼ਰਕ: / I/O concurrency ਲਈ ਹੈ (non-blocking waits), ਜਦਕਿ , , ਅਤੇ PLINQ CPU-intensive ਕੰਮ ਨੂੰ parallelize ਕਰਨ ਲਈ ਹਨ।
I/O ਲਈ / ਤੋਂ ਪਰੇ, .NET ਫਰਾਹਮ ਕਰਦਾ ਹੈ ਲਈ — ਕੰਪਿਊਟੇਸ਼ਨ ਨੂੰ ਮਲਟੀਪਲ ਕੋਰਸ ਦੇ ਪਾਰ ਚਲਾਉਂਦੇ ਹੋਏ। ਮੁੱਖ ਫ਼ਰਕ: / I/O concurrency ਲਈ ਹੈ (non-blocking waits), ਜਦਕਿ , , ਅਤੇ PLINQ CPU-intensive ਕੰਮ ਨੂੰ parallelize ਕਰਨ ਲਈ ਹਨ।
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 ਕੰਮ ਨੂੰ thread pool thread ਉੱਤੇ schedule ਕਰਦਾ ਹੈ — ਇਸ ਨੂੰ CPU-bound computation parallelize ਕਰਨ ਲਈ ਵਰਤੋ (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()) ਆਪੇ ਹੀ cores ਦੇ ਪਾਰ ਕੰਮ ਵੰਡਦੇ ਹਨ — CPU-heavy processing ਲਈ ਸ਼ਾਨਦਾਰ ਸੁਤੰਤਰ ਚੀਜ਼ਾਂ ਦੀ। (ਸਿਰਫ ਉਹਦੇ ਮਤਲਬ ਜੇ genuinely 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
Tasks ਅਤੇ parallelism ਨੂੰ async/await ਤੋਂ ਪਰੇ ਸਮਝਣਾ performant C# applications ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ senior-level ਗਿਆਨ ਹੈ, ਅਤੇ I/O concurrency ਅਤੇ CPU parallelism ਵਿਚਕਾਰ ਮਹੱਤਵਪੂਰਨ ਫ਼ਰਕ ਮੁੱਖ insight ਹੈ — ਸ਼ਾਂਤ ਦਾ ਆਮ ਨੁਕਤਾ। async/await I/O-bound concurrency ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ (waits ਦੌਰਾਨ threads ਨੂੰ ਆਜ਼ਾਦ ਕਰਦੇ ਹੋਏ) ਪਰ CPU parallelism ਨਹੀਂ ਜੋੜਦਾ, ਜਦਕਿ CPU-bound ਕੰਮ (computations, data processing) cores ਦੇ ਪਾਰ ਅਸਲ parallelism ਤੋਂ ਲਾਭਜਨਕ ਹੈ Task.Run ਦੇ ਰਾਹ (CPU ਕੰਮ ਨੂੰ thread pool threads ਵਿੱਚ offload ਕਰਦੇ ਹੋਏ), Parallel.For/ForEach, ਅਤੇ PLINQ (.AsParallel())।
ਕਿਹੜਾ tool ਫਿੱਟ ਹੈ ਇਹ ਜਾਣਨਾ — I/O ਲਈ async/await, CPU-bound ਕੰਮ ਲਈ TPL parallelism tools — effective performance optimization ਲਈ ضروری ہے، ਕਿਉਂਕਿ ਗਲਤ ਵਰਤੋ ਕਰਨਾ (ਜਿਵੇਂ async ਤੋਂ computation ਨੂੰ ਤੇਜ਼ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਨਾ, ਜਾਂ I/O ਲਈ threads ਸ਼ੁਰੂ ਕਰਨਾ ਜੋ async ਕੁਸ਼ਲਾਈ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ) ਬੇਅਸਰ ਹੈ।
ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਹੈ thread safety ਨੂੰ ਸਮਝਣਾ: parallel ਕੋਡ shared state ਨੂੰ access ਕਰਦਾ ਹੈ synchronization ਦੀ ਜ਼ਰੂਰਤ ਹੈ (lock, Interlocked atomic operations ਲਈ, ਜਾਂ thread-safe collections ਜਿਵੇਂ ConcurrentDictionary) race conditions ਤੋਂ ਬਚਣ ਲਈ — parallel code ਵਿੱਚ critical correctness ਚਿੰਤਾ।
I/O-vs-CPU ਫ਼ਰਕ, parallelism tools (Task.Run, Parallel, PLINQ), ਅਤੇ thread-safety requirements ਨੂੰ ਸਮਝਣਾ correct, performant concurrent ਅਤੇ parallel C# ਲਿਖਣ ਲਈ ਕੀਮਤੀ ਹੈ।
ਜਿਵੇਂ modern applications ਨੂੰ ਅਕਸਰ I/O concurrency ਅਤੇ CPU parallelism ਦੋਵਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਜਿਵੇਂ ਸਹੀ approach ਚਣਨਾ ਅਤੇ thread safety ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣਾ parallel code ਨੂੰ effective ਅਤੇ correct ਬਣਾਉਂਦਾ ਹੈ, ਇਹ performance-sensitive C# development ਲਈ ਮਹੱਤਵਪੂਰਨ, frequently-relevant senior knowledge ਹੈ।