async/-ის გარდა I/O-სთვის, .NET გთავაზობთ -სთვის — გამოთვლების გაშვებას რამდენიმე ბირთვზე. ძირითადი განსხვავება: / არის I/O concurrency-სთვის (არა-blocking დაცდებისთვის), ხოლო , და PLINQ არის CPU-intensive სამუშაოს parallelizirებისთვის.
async/-ის გარდა I/O-სთვის, .NET გთავაზობთ -სთვის — გამოთვლების გაშვებას რამდენიმე ბირთვზე. ძირითადი განსხვავება: / არის I/O concurrency-სთვის (არა-blocking დაცდებისთვის), ხოლო , და PLINQ არის CPU-intensive სამუშაოს parallelizirებისთვის.
awaitasyncawaitTask.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 განაწილებს სამუშაოს thread pool thread-ზე — გამოიყენეთ CPU-bound გამოთვლის parallelizirებისთვის (არა I/O-სთვის, სადაც async/await უკვე საკმარისია დამატებითი threads-ის გარეშე).
// 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 და PLINQ (.AsParallel()) ავტომატურად ანაწილებენ სამუშაოს ბირთვებზე — შესანიშნავია CPU-heavy დამოუკიდებელი ელემენტების დამუშავებისთვის. (მხოლოდ ღირებული ნამდვილი CPU-bound-ის, დიდი ოდენობის სამუშაოსთვის — არის 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
Tasks და parallelism-ის გაგება async/await-ის გამო არის მნიშვნელოვანი უმცროსი დონის ცოდნა performant C# აპლიკაციების აგებისთვის, და კრიტიკული განსხვავება I/O concurrency-სა და CPU parallelism-ს შორის არის ძირითადი insight — ხშირი დაბნეულობის წერტილი. async/await მოცემულია I/O-bound concurrency-სთვის (threads-ის გათავისუფლება დაცდის დროს), მაგრამ არ ემატება CPU parallelism-ს, ხოლო CPU-bound სამუშაო (გამოთვლები, მონაცემთა დამუშავება) სარგებლობს ნამდვილი parallelism-ით ბირთვებზე Task.Run-ის საშუალებით (CPU სამუშაოს thread pool thread-ზე გატანა), Parallel.For/ForEach და PLINQ (.AsParallel()).
იმის ცოდნა, რომელი ინსტრუმენტი შესაფერი არის — async/await I/O-სთვის, TPL parallelism ინსტრუმენტები CPU-bound სამუშაოსთვის — აუცილებელია ეფექტური performance optimization-ისთვის, რადგან არასწორი გამოყენება (მაგ., async-სთან მოლოდინი გამოთვლის დაჩქარებისთვის, ან threads-ის ატყვევება I/O-სთვის, რომელიც async ეფექტურად პასუხობს) არ არის ეფექტური.
თანაბრად მნიშვნელოვანი არის thread safety-ის გაგება: parallel კოდი, რომელიც მეტ state-ზე წვდება, საჭიროებს synchronization-ს (lock, Interlocked atomic ოპერაციებისთვის, ან thread-safe collections, როგორიცაა ConcurrentDictionary) race conditions-ის თავიდან ასაცილებლად — კრიტიკული correctness concern parallel კოდში.
I/O-vs-CPU განსხვავების, parallelism ინსტრუმენტების (Task.Run, Parallel, PLINQ) და thread-safety მოთხოვნების გაგება ღირებულია სწორი, performant concurrent და parallel C#-ის ჩასაწერად.
მას შემდეგ, რაც თანამედროვე აპლიკაციებს ხშირად სჭირდება I/O concurrency და CPU parallelism, და რადგან სწორი მიდგომის არჩევა და thread safety-ს სწორად მოუცდელი არის parallel კოდს ეფექტური და სწორი გამოსახვის ის, რაც აძლევს, ეს არის მნიშვნელოვანი, ხშირად აქტუალური უმცროსი ცოდნა performance-sensitive C# განვითარებისთვის.