Conas a oibríonn Tasks agus comhthreodachas taobh thiar d'async/await?

Question

Accepted Answer

Taobh thiar d'`async`/`await` do I/O, soláthraíonn .NET an **Task Parallel Library (TPL)** do **chomhthreodachas uilladh le CPU (CPU-bound parallelism)** — ríomhanna á rith ar chúrsaí il-bhárúla. An príomh-dhidheálú: is don shuimeadh I/O (folaingthe neamhbhac) a bhíonn `async`/`await`, agus is do shaothar uilladh le CPU (CPU-bound work) a bhíonn `Task.Run`, `Parallel`, agus PLINQ.

## An didheálú ríthábhachtach: suimeadh in aghaidh chomhthreodachais

```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 — saothar uilladh le CPU a bhogadh go snáithe cúltaca

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

Sceidealann `Task.Run` saothar ar snáithe poll-snáitheanna — úsáid é chun saothar uilladh le CPU a chomhthreodú (NÍL do I/O, áit ar leor async/await cheana féin gan snáitheanna breise).

## Parallel agus PLINQ — comhthreodachas sonraí

```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();
```

Dhéanann `Parallel.For`/`ForEach` agus **PLINQ** (`.AsParallel()`) saothar a dháileadh go huachaireamhach ar chúrsaí — go hiontach do phróiseáil uilladh le CPU ar mhíreanna neamhspleách. (Ní fiú ach do shaothar fíor-uilladh le CPU agus leor-méid — tá ofar ann.)

## Sábháilteacht snáithe (an chuid dhian)

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

## Cén fáth a bhíonn sé tábhachtach

Is eolas thábhachtach ar dhéanamh iomaíochta fhoinse shinsearach an tuiscint ar Thasks agus ar chomhthreodachas taobh thiar d'async/await chun feidhmchláir C# fheidhmíochta a thógáil, agus is é an **príomh-dhidheálú idir suimeadh uilladh le I/O agus comhthreodachas uilladh le CPU** an príomh-thuiscint — pointe mearbhaill choiteann. Láimhseálann `async`/`await` suimeadh uilladh le I/O (snáitheana a fhaoirsiú le linn bhreithnithe), ach ní chuireann sé leis an gcomhthreodachas uilladh le CPU, agus is dhíol leis saothar uilladh le CPU (ríomhanna, próiseáil sonraí) ó bhreisiú fíor-chomhthreodachais ar chúrsaí trí **`Task.Run`** (saothar uilladh le CPU a bhogadh go snáitheana poll), **`Parallel.For`/`ForEach`**, agus **PLINQ** (`.AsParallel()`).

Is ríthábhachtach an oiread ar an uirlis cheart — async/await do I/O, uirlisí comhthreodachais TPL do shaothar uilladh le CPU — chun optamú feidhmíochta éifeachtach, mar is neamhéifeachtach a bheith ag ioncam an ceann mícheart (m.sh. a bheith ag súil go luas suas ar ríomhanna le async, nó snáitheana nua a chroitheadh suas do I/O a láimhseálann async go héifeachtach).

Is ionann an dá ghné chomh tábhachtach **sábháilteacht snáithe**: saothar comhthreodach ag rochtain ar stáit roinnte riachtanach sioncrónachas (`lock`, `Interlocked` do oibríochtaí adamhach, nó bailiúcháin teared snáithe cosúil le `ConcurrentDictionary`) chun imirt chluichí a sheachaint — imní dhomhain cheart ar shonrasc i saothar comhthreodach.

Is fiú an didheálú I/O-vs-CPU, na huirlisí comhthreodachais (Task.Run, Parallel, PLINQ), agus na riachtanais sábháilteachta snáithe a thuiscint chun C# cheart, feidhmíochta á scríobh.

De bharr gur ghá do thairiscintí nua-aimseartha suimeadh uilladh le I/O agus comhthreodachas uilladh le CPU araon, agus dé bharr gur an roghnú an cur chuige ceart agus an láimhseáil ar shábháilteacht snáithe go ceart atá déanta ar shaothar comhthreodach éifeachtach agus ceart, is eolas thábhachtach, minic-bhaint é seo d'fhorbairt C# uilladh feidhmíochta-bhraistinithe.