Carbon IT · Formation .NET

Asynchronisme, threads et parallélisme en .NET

La formation a trois niveaux : notions de base, notions avancées et notions profondes. Chaque niveau contient des simulateurs, des exemples de code et un QCM.

Utiliser cette page

  1. Choisissez un niveau

    Commencez par l'onglet « Notions de base ». Passez au niveau suivant quand le QCM de l'onglet donne au moins 80 %.

  2. Utilisez les simulateurs

    Changez les réglages. Cliquez sur « Suivant » pour avancer d'une étape. Lisez le message sous chaque simulateur.

  3. Faites le QCM de l'onglet

    Chaque réponse affiche une explication. Pour un score inférieur à 80 %, refaites les simulateurs des thèmes en erreur.

Niveau 1

Notions de base

Ces notions suffisent pour écrire du code async correct. Elles expliquent async, await et Task, et les erreurs fréquentes.

Trois notions à séparer

L'asynchronisme libère un thread. Le parallélisme utilise plusieurs threads.

I/O-bound

Asynchronisme

Le thread n'attend pas la fin d'une I/O. Pendant un appel à une base de données ou à une API HTTP, le thread retourne au ThreadPool. Outils : async, await, Task.

CPU-bound

Parallélisme

Plusieurs calculs s'exécutent en même temps sur plusieurs cœurs. Outils : Parallel, PLINQ, Task.Run hors serveur web.

Les deux

Concurrence

Plusieurs opérations sont en cours au même moment. Elles s'exécutent en même temps ou à tour de rôle.

À retenir. Une Task représente une opération. Une Task n'est pas un thread. L'instruction await ne bloque pas le thread. L'asynchronisme augmente le débit d'un serveur. Le parallélisme réduit la durée d'un calcul.

Glossaire

Cette page utilise ces termes avec ce sens uniquement.

TermeDéfinition
ThreadUnité d'exécution du système d'exploitation. Un thread exécute du code et lit ou modifie des objets.
CœurUnité de calcul du processeur. Un cœur exécute un seul thread à la fois. Cette page compte les cœurs logiques.
ThreadPoolEnsemble de threads réutilisables. Chaque process .NET a un seul ThreadPool.
WorkerThread du ThreadPool.
TaskObjet qui représente une opération. La Task contient l'état, le résultat ou l'exception de l'opération.
I/OOpération d'entrée ou de sortie : base de données, HTTP, fichier, socket.
BloquerArrêter un thread jusqu'à la fin d'une opération. Un thread bloqué ne fait pas d'autre travail.
SuspendreArrêter une méthode async à un await. Le thread est libéré.
StarvationManque de workers libres dans le ThreadPool. Les workers sont bloqués et la file de travail grandit. La latence augmente, le CPU reste bas. Voir le simulateur.
ContinuationCode à exécuter après la fin d'une Task. Avec await, la continuation est la suite de la méthode.
State machineStructure générée par le compilateur pour chaque méthode async. Elle garde la position et les variables de la méthode.
PileMémoire propre à un thread. Elle contient les appels en cours et les variables locales.
HeapMémoire partagée par tous les threads du process. Tous les objets sont sur le heap.
SynchronizationContextObjet qui indique où exécuter une continuation. Exemple : le thread UI en WPF.
ExecutionContextObjet qui transporte les données du flux logique d'un await à l'autre. Exemple : AsyncLocal.

Le thread

Un thread exécute du code. Un thread ne possède pas les objets. Un thread n'est pas une Task. Un thread n'est pas un cœur.

Contenu d'un thread

  • Une pile. Elle contient les appels en cours et les variables locales. Taille réservée : 1 Mo sous Windows, 1,5 Mo sous Linux.
  • Un contexte CPU. Il contient les registres et l'adresse de l'instruction suivante.
  • Un stockage local. Il contient les valeurs [ThreadStatic] et ThreadLocal<T>.
  • Un objet noyau. Le système d'exploitation le gère. L'objet .NET Thread l'enveloppe.

Différences avec les autres concepts

  • Thread et cœur. 200 threads sur 8 cœurs : 8 threads s'exécutent. Les 192 autres attendent un cœur ou sont bloqués.
  • Thread et Task. Un thread exécute beaucoup de Tasks l'une après l'autre. Une Task d'I/O n'utilise pas de thread pendant l'attente.
  • Thread et objets. Les objets sont sur le heap. Tous les threads du process ont accès au heap.

États d'un thread

Le thread s'exécute sur un cœur.
Passe à Ready à la fin de sa tranche de temps.
Le thread est prêt. Il attend un cœur libre.
Passe à Running quand l'ordonnanceur le choisit.
Le thread attend une I/O, un verrou, .Result ou Thread.Sleep.
Passe à Ready à la fin de l'attente.

Thread bloqué. Un thread bloqué n'utilise pas le CPU. Mais il garde sa pile et ne fait pas d'autre travail. Dans le ThreadPool, chaque thread bloqué est un worker en moins pour les requêtes. Cette perte est la cause de la starvation.

Exemple : thread de chaque appel

Ligne 5. Après await, la suite de Main ne revient pas sur T1. Une application console n'a pas de SynchronizationContext. La continuation s'exécute donc sur un worker. ASP.NET Core fonctionne de la même façon.

Créer un thread ou utiliser le ThreadPool

APIThread utiliséUsage
new Thread(...)Nouveau thread dédié. La création prend de 10 à 100 µs et réserve une pile.Cas rares : priorité, apartment COM.
ThreadPool.QueueUserWorkItemWorkerAPI de bas niveau. Utilisez Task.Run.
Task.Run(...)WorkerLibérer le thread UI d'un calcul. Paralléliser un calcul.
StartNew(..., LongRunning)Thread dédié, hors ThreadPoolBoucle sans fin ou travail bloquant long.
await d'une I/OAucun thread pendant l'attente. Un worker pour la continuation.Toutes les I/O.

Pour aller plus loin. L'ordonnanceur du système, les changements de contexte et le fonctionnement interne du ThreadPool sont dans l'onglet Notions profondes.

Simulateur : starvation, code bloquant et code async

Des requêtes HTTP arrivent sur une API ASP.NET Core. Chaque requête fait 20 ms de calcul, un appel à la base de données, puis 20 ms de calcul. Le ThreadPool commence avec peu de workers. Il ajoute un worker toutes les 500 ms si la file n'est pas vide.

Mode
Worker en calculWorker bloqué sur la baseWorker libreI/O en cours sans threadRequête en file

Temps simulé

0 ms

Terminées

0

Workers

0

En file

0

Latence moyenne

–

Latence maximale

–

Workers du ThreadPool

File d'attente du ThreadPool

I/O en cours, aucun thread utilisé

ModeRequêtesDurée baseWorkers max.Temps totalLatence moy.

Comparaison. Exécutez les deux modes avec les mêmes réglages. Comparez les lignes du tableau. En mode bloquant, les workers restent rouges pendant tout l'appel à la base. La file augmente. Le ThreadPool ajoute les workers lentement. C'est la starvation.

await étape par étape

Regardez le thread qui exécute chaque ligne. Regardez le moment où le thread retourne au ThreadPool.

  • Thread actuel
  • Threads utilisés par la requête
  • Méthode Get
  • Méthode GetUserAsync

await séquentiel et Task.WhenAll

Trois appels sont indépendants. Démarrez les trois appels. Attendez ensuite les trois résultats.

Temps écoulé : 0 ms

Résultat. En séquentiel, la durée est la somme des appels. Avec WhenAll, la durée est celle de l'appel le plus long. Dans les deux cas, aucun thread n'attend. Le gain porte sur la latence, pas sur les threads.

Concurrence bornée : Parallel.ForEachAsync

40 appels vers une API partenaire. Cette API accepte 10 connexions simultanées. Au-dessus de 10, elle ralentit et retourne des erreurs 429.

Temps total

Connexions simultanées

Réponses 429

Appel normalAppel ralenti ou 429 avec nouvel essaiUne ligne = un emplacement de concurrence

Exceptions : .Result, GetResult() et await

GetUserAsync lève une HttpRequestException. Choisissez une façon d'attendre. Le tableau indique l'exception reçue par l'appelant.

Une Task peut contenir plusieurs exceptions, par exemple avec WhenAll. L'API synchrone de .NET 4.0 regroupe donc toujours les exceptions dans une AggregateException. await relance la première exception d'origine et garde sa stack trace.

Exception non observée. Une Task en erreur sans code qui l'attend déclenche TaskScheduler.UnobservedTaskException pendant sa finalisation. Le process continue. L'erreur reste invisible.

Mauvaises pratiques : description, cause, correction

Cliquez sur un titre pour afficher le détail.

Évaluation · Niveau 1

QCM : notions de base