Task'lar ve paralelizm async/await'in ötesinde nasıl çalışır?

Question

Accepted Answer

I/O için `async`/`await`'in ötesinde .NET, **CPU-bound paralelizm** için **Task Parallel Library (TPL)** sağlar — hesaplamaları birden fazla core'da çalıştırır. Temel fark: `async`/`await` I/O eşzamanlılığı (blocking olmayan bekleme) için kullanılırken, `Task.Run`, `Parallel` ve PLINQ CPU-yoğun işleri paralelleştirmek için kullanılır.

## Kritik fark: concurrency vs 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 işini background thread'e aktar

```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` işi thread pool thread'inde zamanlar — CPU-bound hesaplama paralelleştirmek için kullanın (I/O için DEĞİL, async/await zaten ekstra thread olmadan yeterlidir).

## Parallel ve PLINQ — veri paralelizmi

```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` ve **PLINQ** (`.AsParallel()`) işi core'lar üzerinde otomatik olarak dağıtır — CPU-yoğun bağımsız öğeler işleme için harika. (Gerçekten CPU-bound, büyük işler için değer verir — overhead vardır.)

## Thread safety (zor olan kısım)

```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
```

## Neden önemli

Async/await'in ötesinde Task'lar ve paralelizmi anlamak, performant C# uygulamaları geliştirmek için önemli senior-level bilgidir ve **I/O eşzamanlılığı ile CPU paralelizmi arasındaki kritik fark** ana insight'tır — sık yapılan bir hata kaynağıdır. `async`/`await` I/O-bound eşzamanlılığını yönetir (bekleme sırasında thread'leri serbest bırakır) ancak CPU paralelizmini *eklemez*, oysa CPU-bound işler (hesaplamalar, veri işleme) **`Task.Run`** (CPU işini thread pool thread'lerine aktarma), **`Parallel.For`/`ForEach`** ve **PLINQ** (`.AsParallel()`) aracılığıyla core'lar arasında gerçek paralelizmden faydalanır.

Hangi aracın uygun olduğunu bilmek — I/O için async/await, CPU-bound işler için TPL parallelizm araçları — etkili performans optimizasyonu için gereklidir, çünkü yanlış olanı kullanmak (örn. async'in hesaplamayı hızlandırmasını beklemek, ya da async'in verimli bir şekilde yönettiği I/O için thread oluşturmak) etkisizdir.

Eşit derecede önemli olan **thread safety**'yi anlamaktır: paylaşılan duruma erişen parallel kod senkronizasyon (`lock`, atomik işlemler için `Interlocked`, ya da `ConcurrentDictionary` gibi thread-safe koleksiyonlar) gerektirir — parallel koddaki kritik bir doğruluk sorunu.

I/O-vs-CPU ayrımını, parallelizm araçlarını (Task.Run, Parallel, PLINQ) ve thread-safety gereksinimlerini anlamak, doğru ve performant concurrent ve parallel C# yazmak için değerlidir.

Modern uygulamalar sıklıkla hem I/O eşzamanlılığına hem de CPU paralelizmune ihtiyaç duyduğundan ve doğru yaklaşımı seçmek ile thread safety'yi doğru yönetmek parallel kodu etkili ve doğru hale getirdiğinden, bu, performans-duyarlı C# geliştirme için önemli, sıklıkla kullanılan senior bilgidir.