Tasks اور parallelism کیسے async/await سے آگے کام کرتے ہیں؟

Question

Accepted Answer

I/O کے لیے `async`/`await` سے آگے، .NET **Task Parallel Library (TPL)** فراہم کرتا ہے **CPU-bound parallelism** کے لیے — متعدد cores میں computations چلانے کے لیے۔ اہم فرق: `async`/`await` I/O concurrency کے لیے ہے (non-blocking waits)، جبکہ `Task.Run`، `Parallel`، اور PLINQ CPU-intensive کام کو parallelize کرنے کے لیے ہیں۔

## اہم فرق: concurrency بمقابلہ parallelism

```text
async/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.
```

## Task.Run — CPU کام کو background thread پر منتقل کریں

```csharp
// 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 اور PLINQ — data parallelism

```csharp
// 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 کے لیے بہترین جو independent items کی ہو۔ (صرف genuinely CPU-bound، بڑے کام کے لیے قابلِ قدر ہے — overhead ہے۔)

## Thread safety (مشکل حصہ)

```csharp
// 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 کو سمجھنا senior-level knowledge ہے performant C# applications بنانے کے لیے، اور **I/O concurrency اور CPU parallelism کے درمیان اہم فرق** کلیدی insight ہے — الجھن کا عام نقطہ۔ `async`/`await` I/O-bound concurrency سنبھالتا ہے (waits کے دوران threads کو آزاد کرتے ہوئے) لیکن CPU parallelism شامل نہیں کرتا، جبکہ CPU-bound کام (computations، data processing) cores میں actual parallelism سے فائدہ اٹھاتا ہے **`Task.Run`** کے ذریعے (CPU کام کو thread pool threads پر منتقل کرنا)، **`Parallel.For`/`ForEach`**، اور **PLINQ** (`.AsParallel()`)۔

یہ جاننا کہ کون سا ٹول موزوں ہے — I/O کے لیے async/await، CPU-bound کام کے لیے TPL parallelism tools — effective performance optimization کے لیے ضروری ہے، کیونکہ غلط استعمال (مثال کے طور پر computation کو تیز کرنے کے لیے async کی توقع، یا I/O کے لیے threads شروع کرنا جو async کفایت سے سنبھالتا ہے) غیر مؤثر ہے۔

برابر اہم **thread safety** کو سمجھنا ہے: parallel کوڈ جو shared state تک رسائی حاصل کرتا ہے synchronization کی ضرورت ہے (`lock`، `Interlocked` atomic operations کے لیے، یا thread-safe collections جیسے `ConcurrentDictionary`) race conditions سے بچنے کے لیے — parallel کوڈ میں ایک اہم correctness concern۔

I/O-vs-CPU فرق، parallelism tools (Task.Run، Parallel، PLINQ)، اور thread-safety requirements کو سمجھنا قیمتی ہے صحیح، performant concurrent اور parallel C# لکھنے کے لیے۔

چونکہ جدید applications اکثر I/O concurrency اور CPU parallelism دونوں کی ضرورت رکھتی ہیں، اور چونکہ صحیح approach منتخب کرنا اور thread safety کو صحیح طریقے سے سنبھالنا وہ ہے جو parallel کوڈ کو مؤثر اور صحیح بناتا ہے، یہ performance-sensitive C# development کے لیے اہم، بار بار relevant senior knowledge ہے۔