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
Choisissez un niveau
Commencez par l'onglet « Notions de base ». Passez au niveau suivant quand le QCM de l'onglet donne au moins 80 %.
Utilisez les simulateurs
Changez les réglages. Cliquez sur « Suivant » pour avancer d'une étape. Lisez le message sous chaque simulateur.
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.
| Terme | Définition |
|---|---|
| Thread | Unité d'exécution du système d'exploitation. Un thread exécute du code et lit ou modifie des objets. |
| Cœur | Unité de calcul du processeur. Un cœur exécute un seul thread à la fois. Cette page compte les cœurs logiques. |
| ThreadPool | Ensemble de threads réutilisables. Chaque process .NET a un seul ThreadPool. |
| Worker | Thread du ThreadPool. |
| Task | Objet qui représente une opération. La Task contient l'état, le résultat ou l'exception de l'opération. |
| I/O | Opération d'entrée ou de sortie : base de données, HTTP, fichier, socket. |
| Bloquer | Arrêter un thread jusqu'à la fin d'une opération. Un thread bloqué ne fait pas d'autre travail. |
| Suspendre | Arrêter une méthode async à un await. Le thread est libéré. |
| Starvation | Manque 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. |
| Continuation | Code à exécuter après la fin d'une Task. Avec await, la continuation est la suite de la méthode. |
| State machine | Structure générée par le compilateur pour chaque méthode async. Elle garde la position et les variables de la méthode. |
| Pile | Mémoire propre à un thread. Elle contient les appels en cours et les variables locales. |
| Heap | Mémoire partagée par tous les threads du process. Tous les objets sont sur le heap. |
| SynchronizationContext | Objet qui indique où exécuter une continuation. Exemple : le thread UI en WPF. |
| ExecutionContext | Objet 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]etThreadLocal<T>. - Un objet noyau. Le système d'exploitation le gère. L'objet .NET
Threadl'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
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
| API | Thread 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.QueueUserWorkItem | Worker | API de bas niveau. Utilisez Task.Run. |
Task.Run(...) | Worker | Libérer le thread UI d'un calcul. Paralléliser un calcul. |
StartNew(..., LongRunning) | Thread dédié, hors ThreadPool | Boucle sans fin ou travail bloquant long. |
await d'une I/O | Aucun 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.
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é
| Mode | Requêtes | Durée base | Workers max. | Temps total | Latence 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.
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
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
Niveau 2
Notions avancées
Ces notions expliquent les comportements inattendus : mémoire après await, contexte de reprise, deadlock, async void, tâches de fond et accès concurrents.
Thread libéré : variables locales et services injectés
Les objets sont sur le heap. Le thread exécute seulement le code. Quand le thread retourne au ThreadPool, aucun objet n'est supprimé. Avancez étape par étape.
Pile de T4
Pile de T7
Heap (mémoire partagée)
Les variables locales deviennent des champs
Au premier await qui suspend la méthode, .NET copie cette structure sur le heap. La Task en cours référence la continuation. La continuation référence la state machine. La state machine référence this. Pendant l'I/O, le GC ne supprime donc aucun de ces objets.
La DI ne crée pas de nouvel objet après await
La DI crée un objet pendant une résolution : création du contrôleur ou appel à GetRequiredService. La DI ne voit pas les await. Le scope DI appartient à la requête, pas au thread. Le scope existe jusqu'à la fin de la requête HTTP.
Cas d'erreur
| Cas | Problème |
|---|---|
| Fire-and-forget avec un service scoped | La requête se termine. Le scope est supprimé. Résultat : ObjectDisposedException: Cannot access a disposed context instance. |
Task.WhenAll sur un seul DbContext | Deux opérations en même temps sur un objet non thread-safe. |
| Singleton avec un état modifiable | Toutes les requêtes et tous les threads partagent cet état. Le singleton doit être thread-safe. |
| Singleton qui reçoit un service scoped | Le service scoped devient captif. Il existe pour toujours et toutes les requêtes le partagent. |
Donnée dans [ThreadStatic] | Après await, la valeur est perdue ou appartient à une autre requête. Voir la section suivante. |
[ThreadStatic] et AsyncLocal<T>
Les objets restent disponibles après await. Les données stockées sur le thread posent un problème : identifiant de corrélation, utilisateur actuel, tenant. Dans cet exemple, deux requêtes A et B partagent les workers T4 et T7.
Fonctionnement
AsyncLocal stocke la valeur dans l'ExecutionContext. À chaque await, .NET capture l'ExecutionContext. À la reprise, .NET restaure l'ExecutionContext sur le worker qui reprend. La valeur suit donc le flux logique, pas le thread.
L'ExecutionContext est copié à chaque modification. Une méthode appelée qui change une valeur ne change pas la valeur de l'appelant.
Utilisations dans le framework. IHttpContextAccessor.HttpContext, Activity.Current (trace OpenTelemetry ou Datadog), ILogger.BeginScope et CultureInfo.CurrentCulture utilisent ce mécanisme.
ConfigureAwait : position de la continuation
ConfigureAwait(bool continueOnCapturedContext) indique où exécuter la continuation. Valeur par défaut : true. Dans ce cas, await capture SynchronizationContext.Current et y envoie la continuation.
À retenir. Utilisez ConfigureAwait(false) dans les bibliothèques. Dans le code d'une application ASP.NET Core, il n'a pas d'effet. Il ne change jamais l'ExecutionContext. Il agit seulement quand await suspend la méthode. En UI, après une suspension avec ConfigureAwait(false), l'accès à un contrôle provoque une exception.
Deadlock avec .Result
Application WPF ou WinForms, ou ASP.NET sur .NET Framework. Le SynchronizationContext impose l'exécution de la continuation sur le thread UI.
- Thread UI
- File du Dispatcher
- Task de
LoadAsync - Requête HTTP
async void : raisons de l'éviter
Une méthode async void ne retourne pas de Task. L'appelant ne peut pas l'attendre. L'appelant ne connaît pas sa fin. Une exception arrête le process.
async Task | async void | |
|---|---|---|
| Objet qui représente l'opération | La Task, retournée à l'appelant | Aucun |
await | Possible | Impossible (erreur CS4008) |
| Fin de l'opération | État de la Task, continuation | Inconnue |
| Exception | Stockée dans la Task, relancée par await | Relancée sur un autre thread. Le process s'arrête. |
| try/catch autour de l'appel | Reçoit l'exception, avec await | Ne reçoit jamais l'exception |
| Tests unitaires | Le test attend la fin | Le test se termine avant la méthode |
Conversions implicites dangereuses
Une lambda async passée à un paramètre Action devient async void. Le compilateur ne donne pas d'avertissement. Il choisit Func<Task> seulement si une surcharge l'accepte.
Seul cas accepté : l'event handler
Un délégué EventHandler impose le type de retour void. Dans ce cas, mettez le try/catch dans la méthode. C'est le seul endroit où le code peut recevoir l'exception.
Pour aller plus loin. Le code généré par le compilateur et la chronologie de l'arrêt du process sont dans l'onglet Notions profondes.
Task.Run côté serveur et tâches de fond
Une requête doit faire 80 ms de calcul. Ces frises montrent les threads utilisés dans chaque cas.
1. Appel synchrone : return Ok(Compute());
2. return Ok(await Task.Run(() => Compute()));
3. _ = Task.Run(() => Process(order)); return Accepted();
Cas 2 : avec await
Ce n'est pas une tâche de fond. Le travail reste lié à la requête. T4 est libéré, mais T9 du même ThreadPool travaille. Il n'y a pas de gain, seulement un coût supplémentaire. Task.Run sert à libérer un thread UI, pas une requête HTTP.
Cas 3 : sans await
C'est une tâche de fond, mais sans contrôle. L'hôte ne la suit pas. Un redéploiement l'arrête. Les exceptions sont perdues. Les services scoped sont supprimés. Il n'y a pas de nouvel essai. Ce travail utilise les mêmes workers que les requêtes.
Tâche de fond correcte : Channel et BackgroundService
| Besoin | Solution | Limite |
|---|---|---|
| Travail léger en mémoire : e-mail, notification, recalcul | Channel + BackgroundService | Travail perdu si le process s'arrête brutalement. |
| Travail périodique | BackgroundService + PeriodicTimer | S'exécute sur chaque instance. Attention avec plusieurs pods. |
| Exécution garantie : nouvel essai, reprise après arrêt, plusieurs instances | Hangfire ou Quartz avec persistance. Ou file de messages (Service Bus, RabbitMQ) avec le pattern Outbox. | Infrastructure supplémentaire. |
| Calcul long | Worker service séparé | Déploiement supplémentaire. L'API garde ses workers. |
Race condition
counter++ contient trois opérations : lire, ajouter 1, écrire. Choisissez l'ordre d'exécution des deux threads.
Thread 1
Mémoire partagée
0
Valeur attendue : 2
Thread 2
Choisir la protection
| Besoin | Outil |
|---|---|
| Une seule variable numérique ou une référence | Interlocked (Increment, Add, CompareExchange) |
| Plusieurs variables liées, code synchrone | lock |
Section protégée avec un await | SemaphoreSlim(1, 1) avec WaitAsync et Release dans un finally |
| Collection partagée | ConcurrentDictionary, ConcurrentQueue, Channel |
| Meilleure solution | Pas d'état partagé modifiable. Chaque tâche retourne son résultat. Le code combine les résultats à la fin. |
Pour aller plus loin. Les instructions du processeur et le protocole de cache derrière Interlocked sont dans l'onglet Notions profondes.
Élider async et await : conséquences
La méthode retourne la Task sans l'attendre. La méthode se termine donc dès le démarrage de l'opération.
| Ressource supprimée trop tôt | Symptôme |
|---|---|
HttpClient | TaskCanceledException: The operation was canceled ou ObjectDisposedException |
DbContext | ObjectDisposedException: Cannot access a disposed context instance |
Stream, FileStream | ObjectDisposedException: Cannot access a closed file |
SqlConnection | Connexion fermée pendant la lecture |
Erreur intermittente. Si l'opération se termine avant Dispose, le code fonctionne. Exemples : cache, réponse très rapide. L'erreur apparaît donc en production et pas en local.
Autres effets, même sans using
- Un
try/catchdans la méthode ne reçoit pas les erreurs async. L'exception arrive plus tard, chez l'appelant. - La méthode n'apparaît pas dans la stack trace async. Le diagnostic est plus difficile.
- Une erreur de validation d'argument se produit immédiatement à l'appel. Elle n'est pas stockée dans la Task.
Task et ValueTask
Une Task est un objet sur le heap. Chaque appel à une méthode async crée donc une allocation. ValueTask évite cette allocation quand le résultat est déjà disponible.
Contenu de la struct
Une ValueTask est une petite struct. Son champ _obj indique lequel des trois cas s'applique.
| Cas | _obj | Exemple |
|---|---|---|
| 1. Résultat déjà disponible | null. La valeur est dans _result. | Le cache : ValueTask.FromResult(user) |
| 2. Enveloppe une Task | Une Task<T> | Le chemin lent : new ValueTask<User>(LoadUserAsync(id)) |
| 3. Source réutilisable | Un IValueTaskSource<T> | Socket.ReceiveAsync, Channel.Reader.ReadAsync |
IValueTaskSource est une interface. Elle offre les mêmes services qu'une Task : un état, une continuation, un résultat. Une Task terminée reste terminée pour toujours. Un IValueTaskSource se remet à zéro après la lecture du résultat et sert à l'opération suivante. Il n'y a aucune allocation, même pour une vraie opération asynchrone. Ces sources sont internes au framework : vous ne les écrivez presque jamais.
| Critère | Task | ValueTask |
|---|---|---|
| Nature | Classe, sur le heap | Struct. Contient un résultat, une Task ou un objet réutilisable. |
| Résultat déjà disponible | Une allocation (sauf résultats en cache, par exemple Task.CompletedTask) | Aucune allocation |
Nombre d'await | Autant que nécessaire | Un seul |
WhenAll, .Result, stockage dans un champ | Autorisés | Interdits. Appelez d'abord .AsTask(). |
| Usage | Par défaut | Chemin critique, résultat souvent synchrone, gain mesuré |
Règle : une seule consommation. Une ValueTask peut utiliser un objet réutilisé (IValueTaskSource). Après le premier await, cet objet peut servir à une autre opération. Un deuxième await, un .Result ou un WhenAll sur la même ValueTask donne un comportement indéfini : mauvais résultat, exception ou blocage.
Image : un ticket de vestiaire
Une Task est un reçu. Vous pouvez le relire autant de fois que vous voulez. Une ValueTask est un ticket de vestiaire. Le ticket en papier est la struct : il est copié puis jeté. Le crochet est l'objet réutilisé sur le heap. Après la remise du manteau, le crochet sert au client suivant. Un deuxième passage avec le même ticket donne une erreur, ou le manteau d'un autre client.
ValueTask (struct, copiée) Heap
┌─────────────────────┐ ┌─────────────────────────────┐
│ _obj ─────────────────────────▶ │ IValueTaskSource du Socket │
│ _token = 7 │ │ version actuelle : 7 │
└─────────────────────┘ └─────────────────────────────┘
1. await vt → résultat lu, la source se remet à zéro et passe en version 8
2. await vt → le token 7 ne correspond plus : InvalidOperationException,
ou le résultat d'une autre opération
La struct n'est donc pas réutilisée. Elle est dépilée comme toute struct. Ce qui est réutilisé, c'est l'objet vers lequel elle pointe. Dans les cas 1 et 2, un deuxième await fonctionnerait. Mais l'appelant ne sait pas quel cas il reçoit : la règle s'applique toujours.
ValueTask dans EF Core
| Méthode | Retour | Raison |
|---|---|---|
FindAsync | ValueTask<T?> | Elle cherche d'abord dans le change tracker. Si l'entité y est, le résultat est immédiat, sans requête SQL. |
AddAsync | ValueTask<EntityEntry> | Elle termine tout de suite, sauf avec certains générateurs de clé (HiLo). |
ToListAsync, FirstOrDefaultAsync, SaveChangesAsync | Task<T> | Elles vont presque toujours en base. Une ValueTask n'apporterait rien. |
À retenir. Utilisez Task par défaut. Utilisez ValueTask seulement sur un chemin critique, quand le résultat est souvent disponible tout de suite et qu'une mesure montre le gain. Exemples dans .NET : Stream.ReadAsync, Channel.Reader.ReadAsync.
Évaluation · Niveau 2
QCM : notions avancées
Niveau 3
Notions profondes
Ces notions décrivent les mécanismes internes : ordonnanceur du système, ThreadPool, code généré par le compilateur et instructions du processeur.
Le thread dans le système
Changement de contexte
L'ordonnanceur remplace parfois le thread d'un cœur par un autre thread. Il enregistre les registres de l'ancien thread. Il charge les registres du nouveau thread. Cette opération dure environ une microseconde.
Le coût indirect est plus grand. Les caches du cœur contiennent les données de l'ancien thread. Le nouveau thread commence donc avec des caches inutiles. Plus de threads actifs que de cœurs donne plus de changements de contexte et moins de travail utile.
Threads d'un process .NET
| Thread | Rôle | Dans le ThreadPool |
|---|---|---|
| Thread principal | Exécute Main. En ASP.NET Core, il démarre l'hôte, puis attend l'arrêt. | Non |
| Workers | Exécutent les requêtes HTTP, les continuations, Task.Run, Parallel et les timers. | Oui |
| Threads I/O | Reçoivent les signaux de fin d'I/O du système (IOCP sous Windows, epoll sous Linux). Ils mettent les continuations en file. | Particulier |
| Threads du GC | En mode Server GC (valeur par défaut d'ASP.NET Core) : un thread de GC par cœur. | Non |
| Finalizer | Exécute les finaliseurs ~MaClasse(). | Non |
| Threads dédiés | Créés par new Thread() ou TaskCreationOptions.LongRunning. | Non |
Foreground et background. Les workers sont des threads « background » : le process s'arrête sans les attendre. Un new Thread() est « foreground » par défaut : le process attend sa fin. Pour changer ce comportement, réglez IsBackground = true.
Simulateur : threads et cœurs
L'ordonnanceur du système donne un cœur à chaque thread prêt, pendant une tranche de temps. Chaque case est une tranche de temps. Le numéro indique le thread. Un filet rouge à gauche indique un changement de contexte.
Threads
Travail utile par tranche
–
Utilisation CPU
–
Changements de contexte
0
Piles réservées
–
Essai 1. Choisissez « Calcul CPU » et 4 cœurs. Passez de 4 à 32 threads. Le travail utile diminue.
Essai 2. Choisissez « I/O bloquante » et 4 cœurs. Avec 4 threads, les cœurs restent inactifs. Augmentez le nombre de threads pour occuper les cœurs.
Le ThreadPool interne
Chaque process a un seul ThreadPool. ASP.NET Core, Task.Run, les continuations, Parallel et les timers l'utilisent. Depuis .NET 6, le ThreadPool est écrit en C#. Il fonctionne de la même façon sous Windows et sous Linux.
┌──────────────────────────── ThreadPool ────────────────────────────┐
requêtes HTTP ►│ File GLOBALE (FIFO) │
timers │ │ │
code externe │ ▼ │
│ T1 [file locale] T2 [file locale] T3 [file locale] ... │
│ ▲ le worker prend en LIFO ◄── les autres volent en FIFO │
└────────────────────────────────────────────────────────────────────┘
▲
fin d'une I/O ──────────┘ le système signale la fin (IOCP / epoll) → continuation en file
Réglages du ThreadPool
| Réglage | Valeur par défaut | Effet |
|---|---|---|
| Minimum de workers | Environment.ProcessorCount | Sous le minimum, le ThreadPool crée un worker immédiatement pour chaque travail en attente. |
| Maximum de workers | 32 767 (64 bits) | Limite absolue. Ne changez pas cette valeur. |
| Injection au-dessus du minimum | Environ 1 thread toutes les 500 ms | La file n'avance pas : le ThreadPool ajoute un worker. Ce rythme est lent volontairement. |
| Hill climbing | Toujours actif | Le ThreadPool mesure le débit. Il essaie un worker de plus ou de moins. Il garde le meilleur résultat. |
| Retrait | Après environ 20 s d'inactivité | Le ThreadPool supprime un worker inactif. Il ne descend pas sous le minimum. |
| Détection de blocage (.NET 6+) | Active | Task.Wait ou .Result sur un worker accélère un peu l'injection. Cette détection réduit la starvation. Elle ne la supprime pas. |
Raison de l'injection lente
Le ThreadPool suppose un travail court et non bloquant. Un worker par travail en attente donnerait des milliers de threads pendant un pic de charge. Ces threads utiliseraient beaucoup de mémoire et de changements de contexte. Le ThreadPool fait donc attendre le travail. Cette règle est efficace avec du code async. Elle est mauvaise avec du code bloquant.
Nombre de threads utile
| Type de travail | Nombre de threads utile | Raison |
|---|---|---|
| Calcul (CPU-bound) | Environ le nombre de cœurs | Plus de threads donne plus de changements de contexte. |
| I/O async | Environ le nombre de cœurs | Aucun thread n'attend. Chaque worker exécute les continuations l'une après l'autre. |
| I/O bloquante | Beaucoup plus que le nombre de cœurs | Les threads bloqués ne travaillent pas. Le ThreadPool doit en ajouter, lentement. |
Cœurs logiques et cœurs physiques. ProcessorCount compte les cœurs logiques. Avec l'hyperthreading, un cœur physique donne deux cœurs logiques. Ces deux cœurs logiques partagent les unités de calcul. Le gain est de 15 à 30 % sur un calcul, pas de 100 %.
API hors ThreadPool et parallélisme par défaut
| API | Comportement |
|---|---|
new Thread, LongRunning | Thread dédié, hors ThreadPool |
Parallel.For, Parallel.ForEach | Utilisent le ThreadPool. Pas de limite explicite par défaut. |
Parallel.ForEachAsync | Parallélisme par défaut : ProcessorCount |
PLINQ .AsParallel() | Parallélisme par défaut : ProcessorCount |
Simulateur : files locales et vol de travail
Le ThreadPool a 4 workers. Une requête HTTP arrive dans la file globale. Au démarrage, chaque requête crée 2 tâches. Ces tâches vont dans la file locale du worker. Un worker libre cherche du travail dans cet ordre : sa file locale (LIFO), la file globale (FIFO), la file d'un autre worker (vol, FIFO).
File globale
Journal
LIFO dans la file locale. La tâche la plus récente utilise souvent les données que le worker vient de lire. Ces données sont encore dans le cache du cœur.
Vol par l'autre extrémité. Le voleur et le propriétaire ne prennent pas la même tâche. Ils n'ont presque jamais besoin de verrou.
Image : une cuisine de restaurant
Les commandes des clients arrivent au passe. Chaque cuisinier a sa pile de préparations sur son plan de travail. Il finit d'abord ce qu'il vient de lancer. Quand son plan est vide, il va au passe. Si le passe est vide, il va chez un collègue débordé. Il prend une préparation en bas de la pile du collègue, sans le gêner.
| Cuisine | ThreadPool |
|---|---|
| Le passe, où arrivent les commandes | La file globale (FIFO). Elle reçoit le travail venu de l'extérieur du pool : requêtes HTTP, timers, Main. |
| La pile d'un cuisinier | La file locale d'un worker. Elle reçoit les Task.Run et les continuations créés par ce worker. |
| Finir la dernière préparation lancée | LIFO : la tâche la plus récente, ses données sont encore dans le cache du cœur. |
| Prendre en bas de la pile d'un collègue | Le vol : la tâche la plus ancienne d'un autre worker, par l'autre extrémité. |
Exemple : un endpoint d'API
L'endpoint lit une commande en base, appelle deux API et calcule le prix de chaque ligne. Log affiche le thread de chaque étape.
| Étape | Ce qui se passe | File utilisée |
|---|---|---|
| ① Requête reçue | Kestrel lit la requête. Il place son traitement dans le pool. Le premier worker libre la prend, par exemple W1. | Globale |
② await FirstAsync | EF envoie le SQL. Aucun thread n'attend la réponse. W1 retourne au pool et sert d'autres requêtes. | Aucune : une I/O est en cours |
| ③ Réponse de la base | La suite de la méthode repart dans le pool. Un worker libre la reprend, par exemple W3. Le numéro de thread change souvent. | Le pool |
④ Deux GetFromJsonAsync | Appeler une méthode async ne met rien en file. Chaque appel s'exécute jusqu'à l'envoi de la requête HTTP, puis rend une Task. W3 est libéré au await. | Aucune |
| ⑤ Réponses reçues | La continuation repart sur un worker libre, par exemple W2. | Le pool |
⑥ 4 Task.Run | W2 est un worker du pool. Les 4 tâches vont sur sa file locale : L1 en bas, L4 en haut. Au await, W2 prend L4 (LIFO). W1 et W4 sont libres : ils volent L1 puis L2 par le bas. | Locale de W2, puis vol |
① début de la requête thread 7 ③ après la base thread 12 ⑤ après les appels HTTP thread 9 calcul ligne 4 thread 9 ← W2 prend le haut de sa file (LIFO) calcul ligne 1 thread 7 ← vol par le bas calcul ligne 2 thread 15 ← vol par le bas calcul ligne 3 thread 9 ⑦ après les calculs thread 15
Les 4 calculs de 100 ms durent environ 200 ms au lieu de 400. Sans le vol, W2 ferait les 4 calculs seul pendant que W1 et W4 attendent. L'ordre d'exécution n'est pas l'ordre de création : ne comptez jamais sur l'ordre des Task.Run.
Remplacez ② par un appel synchrone (First(...) ou FirstAsync(...).Result). W1 reste bloqué pendant la requête SQL. Avec 200 requêtes simultanées, tous les workers sont bloqués. Les nouvelles requêtes restent dans la file globale. Le pool ajoute des threads lentement. C'est la starvation.
Task.Run dans un endpoint. Utilisez-le seulement pour découper un vrai calcul CPU en plusieurs morceaux, comme au ⑥. Un seul await Task.Run(...) libère un worker pour en occuper un autre : aucun gain. Pour une I/O, await suffit.
Injection de threads, conteneurs et SetMinThreads
Ce graphique montre le temps nécessaire pour donner un worker à chaque requête bloquée. Modèle simplifié : création immédiate jusqu'au minimum, puis 1 worker toutes les 500 ms.
Conteneur Kubernetes
Un nœud Kubernetes est une machine. Plusieurs pods partagent ses cœurs. resources.limits.cpu fixe la part maximale d'un conteneur.
| Valeur | Signification |
|---|---|
1000m ou 1 | 1 cœur complet |
500m | La moitié d'un cœur |
100m | 10 % d'un cœur |
2500m | 2,5 cœurs |
L'unité est le millicœur (m) : 1000m = 1 cœur. La limite est un temps de calcul, pas un nombre de cœurs. Linux découpe le temps en tranches de 100 ms. Avec 100m, le conteneur a droit à 10 ms de CPU par tranche, tous threads confondus. Quand il a tout consommé, Linux le met en pause jusqu'à la tranche suivante. C'est le throttling : la latence augmente, alors que le graphe CPU paraît calme.
.NET lit la limite CPU du conteneur. Il arrondit cette limite à l'entier supérieur, avec un minimum de 1. Le résultat donne ProcessorCount, donc le minimum de workers.
ProcessorCount
Minimum de workers
Temps pour 50 requêtes bloquées
SetMinThreads
Solution temporaire. Jusqu'à 100 workers, la création est immédiate. Utilisez ce réglage seulement pour du code bloquant que vous ne pouvez pas corriger tout de suite. Ce réglage augmente la mémoire et les changements de contexte. La correction est du code async de bout en bout.
Diagnostic
| Compteur | Lecture |
|---|---|
| ThreadPool Thread Count | Augmente par paliers d'environ 0,5 s : des threads sont bloqués. |
| ThreadPool Queue Length | Reste supérieur à 0 : du travail attend un worker. |
| ThreadPool Completed Work Item Count | Débit du ThreadPool. |
| % CPU | Bas pendant que la file est pleine : signature de la starvation. |
Signes de la starvation. La latence augmente beaucoup. Le CPU reste bas. Le nombre de threads augmente par paliers. La file reste pleine. Les health checks échouent. Dans un dump, clrstack -all montre des threads arrêtés dans Task.Wait, GetResult ou Monitor.Enter.
async void : code généré
Le compilateur transforme chaque méthode async en state machine et en builder. Le type de retour choisit le builder. Cette différence explique tous les problèmes d'async void.
Raison de l'erreur CS4008 avec await Save()
Le compilateur transforme await x en appels à x.GetAwaiter(), IsCompleted, OnCompleted(continuation) et GetResult(). Il faut donc un objet qui représente l'opération. Une méthode void ne retourne pas d'objet. Le compilateur signale donc error CS4008: Cannot await 'void'. AsyncVoidMethodBuilder ne donne pas non plus de Task en interne.
Comportement de chaque builder
| Appel | AsyncTaskMethodBuilder | AsyncVoidMethodBuilder |
|---|---|---|
Create() | Prépare une Task. | Capture SynchronizationContext.Current. Appelle OperationStarted() si le contexte existe. |
SetResult() | La Task passe à RanToCompletion. Les continuations démarrent. | Appelle OperationCompleted() si le contexte existe. Sinon, aucune action. |
SetException(e) | L'exception est stockée dans la Task. await la relance. | Aucune Task ne peut stocker l'exception. Le builder relance l'exception sur un autre thread. |
OperationStarted et OperationCompleted. Ces appels sont le seul suivi possible d'un async void. Ils passent par le SynchronizationContext. ASP.NET sur .NET Framework comptait ainsi les opérations en cours. xUnit utilise ce mécanisme pour attendre un test async void. ASP.NET Core et les applications console n'ont pas de contexte : il n'y a aucun suivi.
Chronologie : le try/catch de l'appelant ne reçoit pas l'exception
- Pile de T4
- Pile de T7
- Pile de T9
- try de l'appelant actif
Interlocked et cache du processeur
Interlocked n'est pas un appel de méthode normal. Le JIT le remplace par une instruction atomique du processeur.
| Méthode | x86 / x64 | ARM64 |
|---|---|---|
Increment, Add | lock xadd | ldadd (LSE) ou boucle ldxr/stxr |
CompareExchange | lock cmpxchg | cas ou boucle ldxr/stxr |
Exchange | xchg (verrou implicite) | swp |
Avancez étape par étape. Deux cœurs ajoutent 1 au même compteur. Chaque cœur a un cache. La ligne de cache de 64 octets qui contient counter a un état MESI : Modified, Exclusive, Shared, Invalid.
Cœur 1
Cœur 2
CompareExchange : base du code sans verrou
Lien avec lock. Monitor.Enter essaie d'abord un CompareExchange. En cas d'échec, il fait une courte attente active, puis il met le thread en attente dans le noyau. Interlocked ne met jamais un thread en attente. Mais il protège une seule variable.
Évaluation · Niveau 3