Perinteisen /-mallin I/O-operaatioiden ohella .NET tarjoaa -kirjaston — laskujen suorittamiseen useiden ytimien yli. Keskeinen ero: / on I/O-rinnakkaisuutta varten (ei-estävät odotukset), kun taas , ja PLINQ ovat CPU-intensiivisen työn rinnakkaistamiseen.
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 jakaa työn säiekanta-säikeelle — käytä sitä CPU-sidonnaiseen laskentaan rinnakkaisesti (EI I/O-operaatioihin, joiden kanssa async/await riittää ilman ylimääräisiä säikeitä).
// 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 ja PLINQ (.AsParallel()) jakavat työn automaattisesti ytimien yli — erinomainen CPU-raskaaseen riippumattomien kohteiden prosessointiin. (Kannattaa vain todella CPU-sidonnaiselle, suurelle työmäärälle — siinä on yleiskustannusta.)
// 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
Task-objektien ja rinnakkaistamisen ymmärtäminen async/await:n lisäksi on tärkeää seniorijohtoista osaamista suorituskykyisten C#-sovellusten rakentamiseen, ja keskeinen ero I/O-rinnakkaisuuden ja CPU-rinnakkaistamisen välillä on avainperiaate — se on yleinen sekaannuksen lähde. async/await käsittelee I/O-sidonnaisuutta (säikeiden vapauttaminen odotuksien aikana), mutta se ei lisää CPU-rinnakkaistamista, kun taas CPU-sidonnaiset työt (laskelmat, tietojen käsittely) hyötyvät todellisesta rinnakkaistamisesta ytimien yli Task.Run:n (CPU-työn siirtäminen säiekannan säikeille), Parallel.For/ForEach ja PLINQ (.AsParallel()) kautta.
Oikean työkalun valinta — async/await I/O:lle, TPL:n rinnakkaistamisen työkalut CPU-sidonnaisille töille — on olennaista tehokkaalle suorituskyvyn optimointiin, sillä väärän työkalun käyttö (esim. async-odotus laskenta-nopeuden parantamiseen tai säikeiden käynnistäminen I/O:lle, jonka async käsittelee tehokkaasti) on tehotonta.
Yhtä tärkeää on ymmärtää säiketurvallisuus: rinnakkainen koodi, joka käyttää jaettua tilaa, tarvitsee synkronointia (lock, Interlocked atomioperaatioille tai säieturvallisia kokoelmia kuten ConcurrentDictionary) kilpailu-olosuhteiden välttämiseksi — kriittinen oikeellisuuden tekijä rinnakkaisessa koodissa.
I/O-versus-CPU-erottelun, rinnakkaistamisen työkalujen (Task.Run, Parallel, PLINQ) ja säiketurvallisuusvaatimusten ymmärtäminen on arvokasta oikean, suorituskykyisen samanaikaisen ja rinnakkaisen C#-koodin kirjoittamiselle.
Koska nykyaikaiset sovellukset tarvitsevat usein sekä I/O-rinnakkaisuutta että CPU-rinnakkaistamista, ja koska oikean lähestymistavan valinta ja säiketurvallisuuden käsittely oikein ovat se, mikä tekee rinnakkaisesta koodista tehokasta ja oikeaa, tämä on tärkeää, usein relevanttia seniorijohtoista osaamista suorituskyvylle arkaalle C#-kehitykselle.