Async و Multithreading

#Sync و Async: مثال الجرسون في المطعمSync vs async: the restaurant analogy

public IActionResult Get(int id)
{
    var order = db.Orders.Find(id);           // thread blocked ~20 ms
    var rate = http.GetStringAsync(ratesUrl).GetAwaiter().GetResult(); // blocks
    return Ok(order);
}

public async Task<IActionResult> Get(int id, CancellationToken ct)
{
    var order = await db.Orders.FindAsync([id], ct);   // thread released while the DB works
    var rate  = await http.GetStringAsync(ratesUrl, ct);
    return Ok(order);
}

الفايدة في API: نفس عدد الـ threads يستحمل requests أكتر بكتير. ودي scalability مش speed: الـ request الواحد مش بيبقى أسرع.

#async و await بيشتغلوا إزاي من جوّهHow async/await works under the hood

الـ compiler بيحوّل الـ method الـ async لـ state machine (class فيه MoveNext() وحالة بتقول وصلنا لأنهي await).

1. الـ method بتشتغل عادي (synchronously) لحد أول await.
2. لو الـ task اللي بتستناه خلص فعلاً (زي cache hit)، بتكمّل على طول من غير ما تسيب الـ thread.
3. لو لسه ماخلصش، بتسجّل continuation ("كمّل من هنا لما يخلص")، وترجّع Task مش مكتمل للي ناداها، والـ thread بيتحرر.
4. مع network I/O الـ async الحقيقي، مفيش thread مستني: الـ OS بيبلّغ لما الداتا توصل. بعض async APIs للملفات أو providers ممكن تشغّل الشغل الـ blocking على thread.
5. لما العملية تخلص، الـ continuation بيتنفذ على thread من الـ ThreadPool (أو على الـ UI thread في تطبيقات الـ desktop)، ويكمّل من نفس النقطة بكل المتغيرات.
6. لو حصل exception، بيتخزن جوه الـ Task، ويترمي تاني لما تعمل await.

public async Task<decimal> GetTotalAsync(Guid orderId, CancellationToken ct)
{
    var order = await repo.GetAsync(orderId, ct);         // may suspend here
    var rate  = await fx.GetRateAsync(order.Currency, ct); // and here
    return order.Total * rate;                    // resumes with locals intact
}

#Thread و Task و ThreadPoolThread vs Task vs ThreadPool

الـ ThreadPool: مجموعة threads جاهزة بيعيد استخدامها الـ runtime. والـ ASP.NET Core بيخدم كل request على thread منها. ولو عملت block للـ threads دي (.Result)، الـ pool بيخلص، ودي اسمها thread pool starvation.

#Task.Run و WhenAll و WhenAnyTask.Run, WhenAll and WhenAny

Task.Run بيحط شغل على thread من الـ pool. مفيد في الـ UI والـ console للشغل التقيل على الـ CPU. أما في ASP.NET Core فإنت أصلاً على thread من الـ pool، فلفّ الـ I/O بيه overhead بس.

var order = await Task.Run(() => db.Orders.Find(id));   // still blocks a pool thread

var order = await db.Orders.FindAsync([id], ct);

// WhenAll: start everything first, then wait for ALL → total time ≈ the slowest call
var stockTask   = inventory.GetStockAsync(sku, ct);
var priceTask   = pricing.GetPriceAsync(sku, ct);
var reviewsTask = reviews.GetAsync(sku, ct);
await Task.WhenAll(stockTask, priceTask, reviewsTask);           // (1)
var page = new ProductPage(                                      // (2) all complete
    await stockTask, await priceTask, await reviewsTask);

// WhenAny: continue when the FIRST task finishes
var winner = await Task.WhenAny(primary.GetAsync(ct), replica.GetAsync(ct));
var data = await winner;                       // (3) observe result or exception

// WaitAsync (.NET 6+) times out the wait; the CTS times out the operation
using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeoutCts.CancelAfter(TimeSpan.FromSeconds(5));
var receipt = await gateway.ChargeAsync(order, timeoutCts.Token)   // (4)
    .WaitAsync(TimeSpan.FromSeconds(5), ct);

#CancellationTokenCancellation

المستخدم ممكن يقفل صفحة التقرير، أو الـ request ينتهي قبل ما قاعدة البيانات تخلص. بدل ما العملية تفضل شغالة بلا داعي، caller يمرر إشارة إلغاء، وكل طبقة تختار كيف تستجيب لها. الكود يوضح تمرير الإشارة وفحصها؛ الإلغاء تعاوني ومش بيقتل thread بالقوة.

[HttpGet("report")]
// (1) ct is cancelled when the client disconnects
public async Task<IActionResult> Report(CancellationToken ct)
{
    // (2) pass it everywhere
    var rows = await db.Sales.Where(s => s.Year == 2026).ToListAsync(ct);
    foreach (var row in rows)
    {
        ct.ThrowIfCancellationRequested();   // (3) check inside long CPU loops
        Process(row);
    }
    return Ok();
}

// combine the request token with your own timeout
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
cts.CancelAfter(TimeSpan.FromSeconds(10));                             // (4)
await partnerApi.SyncAsync(cts.Token);

الإلغاء تعاوني (cooperative): الـ token مش بيوقف الكود بالعافية، الكود هو اللي بيشيك عليه. ولما يتلغي بيترمي OperationCanceledException، وده مش error، فماتسجّلوش كـ error في الـ logs. EF Core بيمرر token للـ database provider، لكن مش مضمون إن كل provider ينفّذ الإلغاء.

#Race conditions و lock و SemaphoreSlim و InterlockedRace conditions and synchronization primitives

private int _count;
// NOT atomic: read → add → write, so concurrent updates get lost
public void Hit() => _count++;

// 1) lock: one thread at a time (synchronous code only)
// .NET 9+ Lock type (before: private readonly object _gate = new();)
private readonly Lock _gate = new();
public void Add(Item i) { lock (_gate) { _items.Add(i); _total += i.Price; } }

// 2) Interlocked: atomic operations on a single value
Interlocked.Increment(ref _count);

// 3) SemaphoreSlim: works with await, and can allow N at a time
private readonly SemaphoreSlim _refresh = new(1, 1);
public async Task RefreshTokenAsync(CancellationToken ct)
{
    await _refresh.WaitAsync(ct);
    try { _token = await auth.GetTokenAsync(ct); }
    finally { _refresh.Release(); }                // always release in finally
}

#Deadlocks وأشهر أخطاء الـ asyncDeadlocks and common async mistakes

1. .Result و .Wait() (sync over async): بيعمل block للـ thread. وفي الـ UI أو ASP.NET القديم بيعمل deadlock: الـ thread مستني الـ task، والـ task مستني يرجع على نفس الـ thread. وفي ASP.NET Core مفيش SynchronizationContext، فمفيش deadlock، بس فيه thread pool starvation.
2. async void: مفيش Task ترجع، فمحدش يقدر يعمل await، والـ exception بتوقّع الـ process. استخدمه في الـ event handlers بس.
3. نسيان await: العملية بتشتغل fire-and-forget، والـ exceptions بتضيع، والـ DbContext ممكن يتعمله dispose قبل ما تخلص.
4. Fire-and-forget جوه request: _ = SendEmailAsync() بيكمّل بعد ما الـ DI scope يتقفل. استخدم queue أو background job أو outbox.
5. عمليتين مع بعض على نفس الـ DbContext.
6. lock حوالين await: مش مسموح، استخدم SemaphoreSlim.
7. عدم تمرير الـ CancellationToken.

ConfigureAwait(false): بيقول للـ await "مش محتاج ترجع على نفس الـ context". مهم في الـ libraries والـ UI. وفي كود ASP.NET Core نفسه مالوش تأثير، لأن مفيش SynchronizationContext.

Deadlock في الـ locks: thread 1 ماسك A ومستني B، و thread 2 ماسك B ومستني A، فالاتنين واقفين للأبد. والحل ترتيب ثابت للـ locks، و critical sections قصيرة، و timeouts. ونفس الكلام في الـ database transactions.

#Parallel و async و ChannelsParallelism vs asynchrony, and Channels

// CPU-bound: spread across cores
Parallel.For(0, images.Length, i => images[i] = Resize(images[i]));

// I/O-bound with a concurrency limit (.NET 6+)
var options = new ParallelOptions { MaxDegreeOfParallelism = 8, CancellationToken = ct };
await Parallel.ForEachAsync(skus, options,
    async (sku, token) => await SyncStockAsync(sku, token));

// Channel: in-memory async queue; bounded = back-pressure when consumers are slow
var channel = Channel.CreateBounded<OrderPlaced>(capacity: 1000);
await channel.Writer.WriteAsync(evt, ct);                                        // producer
await foreach (var e in channel.Reader.ReadAllAsync(ct)) await HandleAsync(e);   // consumer

جملة تفتكرها: "Concurrency is about dealing with many things at once; parallelism is about doing many things at once."