Az / I/O-hoz való felhasználása mellett a .NET biztosítja a könyvtárat — számítások futtatása több magin. A döntő különbség: az / az I/O párhuzamosságához való (nem blokkoló várakozás), míg a , és PLINQ a CPU-igényes munka paralelizálásához való.
Az / I/O-hoz való felhasználása mellett a .NET biztosítja a könyvtárat — számítások futtatása több magin. A döntő különbség: az / az I/O párhuzamosságához való (nem blokkoló várakozás), míg a , és PLINQ a CPU-igényes munka paralelizálásához való.
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
A Task.Run egy szálkészlet szálján ütemez munkát — használd CPU-kötött számítások paralelizálásához (NEM I/O-hoz, ahol az async/await már elegendő további szálak nélkül).
// 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();
A Parallel.For/ForEach és a PLINQ (.AsParallel()) automatikusan elosztják a munkát a magok között — kiváló CPU-igényes feldolgozáshoz független elemek feldolgozásakor. (Csak nagyobb, valóban CPU-kötött munkánál éri meg — van 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
A Task-ok és a paralelizmus megértése az async/await-en túl fontos senior szintű tudás a performáns C# alkalmazások fejlesztéséhez, és az I/O párhuzamosság és CPU paralelizmus közötti döntő különbség a kulcsmeglátás — gyakori tévesztési pont. Az async/await az I/O-kötött párhuzamosságot kezeli (szálak felszabadítása várakozás alatt), de nem adja meg a CPU paralelizmust, míg a CPU-kötött munka (számítások, adatfeldolgozás) hasznosul a valódi paralelizmusból több mag között a Task.Run (CPU munka szálkészlet szálára való kiszervezése), Parallel.For/ForEach és PLINQ (.AsParallel()) segítségével.
Annak tudása, hogy melyik eszköz illik — async/await az I/O-hoz, a TPL paralelizmus eszközei a CPU-kötött munkához — elengedhetetlen a hatékony teljesítményi optimalizáláshoz, mivel a rossz eszköz használata (pl. async-ra számítás gyorsításáért számítani, vagy szálak indítása az I/O-hez, amit az async hatékonyan kezel) nem hat.
Egy másik fontos szempont a szálbiztonság: a megosztott állapotot elérő párhuzamos kód szinkronizációt igényel (lock, Interlocked atomi operációkhoz, vagy szálbiztos kollekciókat, mint a ConcurrentDictionary) a versenyhelyzetek elkerülésére — kritikus helyességi szempont párhuzamos kódban.
Az I/O-vs-CPU különbség megértése, a paralelizmus eszközei (Task.Run, Parallel, PLINQ) és a szálbiztonság követelményei értékesek a helyes, performáns párhuzamos és párhuzamos C# írásához.
Mivel a modern alkalmazások gyakran igényelnek I/O párhuzamosságot és CPU paralelizmust is, és mivel a helyes megközelítés kiválasztása és a szálbiztonság helyes kezelése az, ami a párhuzamos kódot hatékonnyá és helyessé teszi, ez fontos, gyakran relevancia senior tudás a teljesítményre érzékeny C# fejlesztéshez.