Bagaimana Tasks dan parallelism berfungsi di luar async/await?

Question

Accepted Answer

Di luar `async`/`await` untuk I/O, .NET menyediakan **Task Parallel Library (TPL)** untuk **parallelism terikat-CPU** — menjalankan pengiraan merentas pelbagai teras. Perbezaan utama: `async`/`await` adalah untuk keserentakan I/O (menunggu tanpa-sekat), manakala `Task.Run`, `Parallel`, dan PLINQ adalah untuk menyelarikan kerja intensif-CPU.

## Perbezaan penting: keserentakan 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 — pindahkan kerja CPU ke thread latar belakang

```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` menjadualkan kerja pada thread pool thread — gunakannya untuk menyelarikan pengiraan terikat-CPU (BUKAN untuk I/O, di mana async/await sudah mencukupi tanpa thread tambahan).

## Parallel dan PLINQ — parallelism data

```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` dan **PLINQ** (`.AsParallel()`) mengagihkan kerja secara automatik merentas teras — bagus untuk pemprosesan berat-CPU bagi item bebas. (Hanya berbaloi untuk kerja yang benar-benar terikat-CPU dan bersaiz besar — ada overhead.)

## Keselamatan thread (bahagian yang sukar)

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

## Mengapa ia penting

Memahami Tasks dan parallelism di luar async/await ialah pengetahuan peringkat senior yang penting untuk membina aplikasi C# yang berprestasi, dan **perbezaan penting antara keserentakan I/O dan parallelism CPU** ialah wawasan utama — punca kekeliruan yang biasa. `async`/`await` mengendalikan keserentakan terikat-I/O (membebaskan threads semasa menunggu) tetapi *tidak* menambah parallelism CPU, manakala kerja terikat-CPU (pengiraan, pemprosesan data) mendapat manfaat daripada parallelism sebenar merentas teras melalui **`Task.Run`** (memindahkan kerja CPU ke thread pool threads), **`Parallel.For`/`ForEach`**, dan **PLINQ** (`.AsParallel()`).

Mengetahui alat mana yang sesuai — async/await untuk I/O, alat parallelism TPL untuk kerja terikat-CPU — adalah penting untuk pengoptimuman prestasi yang berkesan, kerana menggunakan yang salah (cth. mengharapkan async untuk mempercepatkan pengiraan, atau memutar threads untuk I/O yang dikendalikan async dengan cekap) tidak berkesan.

Sama pentingnya ialah memahami **keselamatan thread**: kod selari yang mengakses keadaan dikongsi memerlukan penyegerakan (`lock`, `Interlocked` untuk operasi atom, atau koleksi selamat-thread seperti `ConcurrentDictionary`) untuk mengelakkan keadaan perlumbaan — kebimbangan ketepatan kritikal dalam kod selari.

Memahami perbezaan I/O-vs-CPU, alat parallelism (Task.Run, Parallel, PLINQ), dan keperluan keselamatan-thread adalah bernilai untuk menulis C# serentak dan selari yang betul dan berprestasi.

Memandangkan aplikasi moden selalunya memerlukan kedua-dua keserentakan I/O dan parallelism CPU, dan kerana memilih pendekatan yang betul serta mengendalikan keselamatan thread dengan betul ialah perkara yang menjadikan kod selari berkesan dan betul, ini adalah pengetahuan senior yang penting dan kerap relevan untuk pembangunan C# yang sensitif prestasi.