Zaidi ya / kwa I/O, .NET hutoa kwa — kuendesha hesabu kupitia cores nyingi. Tofauti kuu: / ni kwa I/O concurrency (kusubiri bila kuzuia), wakati , , na PLINQ ni kwa kufanya kazi nzito ya CPU kwa parallel.
Zaidi ya / kwa I/O, .NET hutoa kwa — kuendesha hesabu kupitia cores nyingi. Tofauti kuu: / ni kwa I/O concurrency (kusubiri bila kuzuia), wakati , , na PLINQ ni kwa kufanya kazi nzito ya CPU kwa parallel.
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 hupanga kazi kwenye thread pool thread — itumie kufanya hesabu inayotegemea CPU kwa parallel (SIYO kwa I/O, ambapo async/await tayari inatosha bila threads za ziada).
// 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 na PLINQ (.AsParallel()) husambaza kazi kiotomatiki juu ya cores — bora kwa uchakataji mzito wa CPU wa vitu vinavyojitegemea. (Inafaa tu kwa kazi inayotegemea CPU kweli na yenye ukubwa — kuna overhead.)
// 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
Kuelewa Tasks na parallelism zaidi ya async/await ni ujuzi muhimu wa kiwango cha senior kwa kujenga programu za C# zenye utendaji, na tofauti muhimu kati ya I/O concurrency na CPU parallelism ndiyo ufahamu mkuu — sehemu ya kawaida ya kuchanganyikiwa. async/await hushughulikia I/O-bound concurrency (kuachilia threads wakati wa kusubiri) lakini haiongezi CPU parallelism, wakati kazi inayotegemea CPU (hesabu, uchakataji wa data) hunufaika kutoka kwa parallelism halisi juu ya cores kupitia Task.Run (kuhamisha kazi ya CPU kwa thread pool threads), Parallel.For/ForEach, na PLINQ (.AsParallel()).
Kujua chombo kinachofaa — async/await kwa I/O, zana za parallelism za TPL kwa kazi inayotegemea CPU — ni muhimu kwa uboreshaji bora wa utendaji, kwa kuwa kutumia kibaya (mfano kutarajia async kuharakisha hesabu, au kuanzisha threads kwa I/O ambayo async inashughulikia kwa ufanisi) hakufanyi kazi.
Kwa umuhimu sawa ni kuelewa thread safety: msimbo wa parallel unaofikia shared state unahitaji synchronization (lock, Interlocked kwa atomic operations, au thread-safe collections kama ConcurrentDictionary) ili kuepuka race conditions — wasiwasi muhimu wa usahihi katika msimbo wa parallel.
Kuelewa tofauti ya I/O-dhidi-ya-CPU, zana za parallelism (Task.Run, Parallel, PLINQ), na mahitaji ya thread-safety ni jambo la thamani kwa kuandika C# ya concurrent na parallel sahihi na yenye utendaji.
Kwa kuwa programu za kisasa mara nyingi zinahitaji I/O concurrency na CPU parallelism, na kwa kuwa kuchagua njia sahihi na kushughulikia thread safety kwa usahihi ndiyo kunafanya msimbo wa parallel kuwa na ufanisi na sahihi, huu ni ujuzi muhimu, unaohusika mara kwa mara wa senior kwa uendelezaji wa C# nyeti wa utendaji.
Maktaba ya maswali ya mahojiano ya IT yenye majibu ya kina — kutoka Junior hadi Senior.
Changia