Est-ce que l'utilisation de async/wait crée un nouveau thread?
Je suis nouveau sur TPL et je me demande: comment la programmation asynchrone qui prend en charge la nouvelle version de C # 5.0 (via les nouveaux mots-clés async et await) est-elle liée à la création de fils?
Plus précisément, l'utilisation de async/await crée-t-elle un nouveau fil à chaque utilisation? Et s’il existe plusieurs méthodes imbriquées utilisant async/await, un nouveau fil est-il créé pour chacune de ces méthodes?
En bref NON
From Programmation asynchrone avec Async et Await: Threads
Les mots-clés async et wait n'entraînent pas la création de threads supplémentaires créé. Les méthodes asynchrones ne nécessitent pas de multithreading, car async La méthode ne fonctionne pas sur son propre thread. La méthode s'exécute sur le courant contexte de synchronisation et utilise le temps sur le fil uniquement lorsque le la méthode est active. Vous pouvez utiliser Task.Run pour déplacer le travail lié à la CPU vers un fil d’arrière-plan, mais un fil d’arrière-plan n’aide pas le processus c'est juste attendre que les résultats deviennent disponibles.
J'ai donc lu sur le modèle de threading, et Async/Await peut certainement conduire à l'utilisation de nouveaux threads (pas nécessairement créés - le pool les crée au démarrage de l'application). C'est au planificateur de déterminer si un nouveau thread est nécessaire. Et comme je le vois, un appel à une fonction attendue peut avoir des détails internes qui augmentent les chances que le planificateur utilise un autre thread; tout simplement parce que plus de travail signifie plus d'opportunités/de raisons pour que le planificateur divise son travail.
Les opérations asynchrones WinRT ont lieu automatiquement sur le pool de threads. Et généralement, vous appelerez DEPUIS le pool de threads, à l'exception du travail de thread d'interface utilisateur .. Xaml/Input/Events.
Les opérations asynchrones démarrées sur les threads Xaml/UI voient leurs résultats renvoyés au thread d'interface utilisateur [appelant]. Toutefois, les résultats des opérations asynchrones démarrées à partir d'un thread de pool de threads sont livrés à chaque fin d'exécution, ce qui peut ne pas être le même thread que celui utilisé auparavant. La raison derrière ceci est que le code écrit pour le pool de threads est susceptible d'être écrit pour être thread-safe et que c'est aussi pour l'efficacité, Windows n'a pas à négocier ce commutateur de thread.
Encore une fois, en réponse à l'OP, de nouveaux threads ne sont pas nécessairement créés, mais votre application peut utiliser et utilisera plusieurs threads pour effectuer un travail asynchrone.
Je sais que cela semble contredire une partie de la littérature concernant async/wait, mais c'est parce que bien que la construction async/wait n'est pas multithread par elle-même. Les éléments attendus sont le ou l'un des mécanismes par lesquels le planificateur peut diviser le travail et créer des appels entre les threads.
C’est à la limite de mes connaissances actuelles en ce qui concerne l’async et l’enregistrement, il est donc possible que je n’aie pas tout à fait raison, mais j'estime qu’il est important de voir la relation entre les attentes et l’enregistrement.