Tâches asynchrones et types awaiter
Composer des tâches asynchrones avec des types awaiter et promise personnalisés
Tâches asynchrones et types awaiter est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Coroutines asynchrones
Une tâche asynchrone se suspend pendant une entrée-sortie et reprend son exécution une fois l’opération terminée. Combinez co_await avec des API asynchrones pour écrire du code asynchrone sans rappels.
Schéma du type Task
Un Task encapsule une coroutine asynchrone. Il prend en charge co_await pour enchaîner les opérations.
template <typename T>
struct Task {
struct promise_type;
std::coroutine_handle<promise_type> handle;
// ...
};Mécanique de co_await
Lorsque le compilateur rencontre co_await expr, il s’attend à ce que expr soit un objet pouvant être attendu. Un tel objet possède trois méthodes :
await_ready()— renvoie false pour suspendre l’exécution ou true pour ignorer la suspensionawait_suspend(handle)— indique quoi faire pendant la suspensionawait_resume()— indique la valeur à transmettre au code appelant
Exemple d’objet pouvant être attendu : Sleep
Un objet pouvant être attendu qui planifie une reprise après un délai.
struct Sleep {
std::chrono::milliseconds duration;
bool await_ready() const { return false; }
void await_suspend(std::coroutine_handle<> h) {
std::thread([h, this] {
std::this_thread::sleep_for(duration);
h.resume();
}).detach();
}
void await_resume() {}
};
Task<void> example() {
co_await Sleep{500ms};
std::cout << "after 500ms";
}Objet pouvant être attendu pour HTTP
Les bibliothèques fournissent des objets pouvant être attendus pour les requêtes HTTP, les minuteurs et les entrées-sorties de fichiers. Composez-les comme des appels synchrones.
Task<std::string> fetch() {
auto data = co_await http_get("/api/data");
co_return data;
}Composition de tâches
Attendre une tâche dans une autre permet de les enchaîner. La tâche externe se suspend jusqu’à la fin de la tâche interne.
Task<int> outer() {
int x = co_await inner_a();
int y = co_await inner_b();
co_return x + y;
}Tâches parallèles
Pour effectuer un travail asynchrone en parallèle, démarrez les tâches sans attendre immédiatement chacune d’elles, puis attendez-les toutes.
Task<int> sum_tasks() {
auto a = inner_a();
auto b = inner_b();
int x = co_await a;
int y = co_await b;
co_return x + y;
}Propagation des exceptions
Les exceptions levées dans une tâche asynchrone peuvent être capturées dans le unhandled_exception de la promise_type, puis relancées du côté de l’attente.
Annulation
La bibliothèque standard ne fournit pas encore de primitive d’annulation. Les bibliothèques, comme cppcoro et boost.cobalt, créent les leurs, généralement au moyen de jetons d’annulation ou de sources d’arrêt.
Intégration de Boost.Asio
Asio prend nativement en charge les coroutines. Utilisez co_await avec async_read, async_write et les opérations similaires. C’est aujourd’hui la solution la plus claire pour les entrées-sorties asynchrones en C++.
Performances
La reprise d’une coroutine est beaucoup moins coûteuse que le changement de contexte entre fils d’exécution. Le compilateur met souvent en ligne certaines parties de la machine à états. Profilez votre chaîne d’objets pouvant être attendus pour vérifier qu’elle est compilée efficacement.
Évolutions futures
C++23 a ajouté std::generator et diverses améliorations. C++26 pourrait apporter std::execution, fondé sur le modèle expéditeur/récepteur : un cadre asynchrone plus général qui interagit avec les coroutines.
Vérification rapide
Quelles sont les trois méthodes dont un type pouvant être attendu a besoin ?
Récapitulatif
Les tâches asynchrones combinent co_await et des objets pouvant être attendus pour écrire du code asynchrone sans rappels. Ces objets possèdent await_ready, await_suspend et await_resume. Les bibliothèques, comme cppcoro et Asio, fournissent des types prêts à l’emploi pour les tâches et les objets pouvant être attendus.
Questions Fréquemment Posées
La leçon « Tâches asynchrones et types awaiter » est-elle gratuite ?
Oui — le texte complet de « Tâches asynchrones et types awaiter » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Tâches asynchrones et types awaiter » ?
Composer des tâches asynchrones avec des types awaiter et promise personnalisés Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Tâches asynchrones et types awaiter » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Concepts des coroutines : co_await, co_yield, co_return
- Implémenter un générateur simple
- Tâches asynchrones et types awaiter
- Allocation de la trame d’une coroutine