Concurrence & async

Ce que fait réellement await Junior

Le compilateur transforme une méthode async en machine à états. À chaque await sur une opération non terminée, le thread est rendu au ThreadPool. Quand l'I/O se termine (notifiée par le système, IOCP sous Windows ou epoll sous Linux), la suite de la méthode reprend sur un thread disponible, pas forcément le même.

Primitives de synchronisation Confirmé

Le sémaphore en action Confirmé

Un SemaphoreSlim(2) laisse passer au plus deux tâches simultanément. Les autres attendent sans bloquer de thread grâce à WaitAsync. Cas typique : limiter les appels concurrents à une API partenaire qui impose un quota.

public sealed class PartnerClient(HttpClient http)
{
    // Quota partenaire : 2 appels simultanés maximum, partagé par toute l'appli (singleton)
    private readonly SemaphoreSlim _gate = new(initialCount: 2, maxCount: 2);

    public async Task<Quote> GetQuoteAsync(string sku, CancellationToken ct)
    {
        await _gate.WaitAsync(ct);          // attend sans bloquer de thread
        try
        {
            return await http.GetFromJsonAsync<Quote>($"quotes/{sku}", ct)
                   ?? throw new InvalidOperationException("Réponse vide");
        }
        finally
        {
            _gate.Release();                // toujours dans finally
        }
    }
}

// Alternative déclarative pour paralléliser une liste avec un degré borné
await Parallel.ForEachAsync(skus, new ParallelOptions { MaxDegreeOfParallelism = 4, CancellationToken = ct },
    async (sku, token) => await client.GetQuoteAsync(sku, token));

Producteur / consommateur avec Channel

var channel = Channel.CreateBounded<Job>(new BoundedChannelOptions(100)
{
    FullMode = BoundedChannelFullMode.Wait    // le producteur ralentit si la file est pleine
});

// Producteur (ex. endpoint HTTP)
await channel.Writer.WriteAsync(job, ct);

// Consommateur (BackgroundService)
await foreach (var job in channel.Reader.ReadAllAsync(stoppingToken))
    await ProcessAsync(job, stoppingToken);