Asynchrone Aufgaben und Awaiter-Typen
Setzen Sie asynchrone Aufgaben mit eigenen Awaiter- und Promise-Typen zusammen.
Asynchrone Aufgaben und Awaiter-Typen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Asynchrone Coroutines
Ein asynchroner Task wird bei I/O angehalten und fortgesetzt, sobald die Operation abgeschlossen ist. Kombinieren Sie co_await mit asynchronen APIs, um asynchronen Code ohne Callbacks zu schreiben.
Skizze des Task-Typs
Ein Task kapselt eine asynchrone Coroutine. Er unterstützt co_await zur Verkettung.
template <typename T>
struct Task {
struct promise_type;
std::coroutine_handle<promise_type> handle;
// ...
};Funktionsweise von co_await
Wenn der Compiler co_await expr sieht, erwartet er, dass expr ein Awaitable ist. Ein Awaitable besitzt drei Methoden:
await_ready()– false zum Anhalten, true zum Überspringenawait_suspend(handle)– was während des Anhaltens geschehen sollawait_resume()– der Wert, der dem aufrufenden Code übergeben wird
Awaitable-Beispiel: Sleep
Ein Awaitable, das nach einer Verzögerung eine Fortsetzung plant.
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";
}Awaitable für HTTP
Von Bibliotheken bereitgestellte Awaitables für HTTP-Anfragen, Timer und Datei-I/O. Sie können wie synchrone Aufrufe zusammengesetzt werden.
Task<std::string> fetch() {
auto data = co_await http_get("/api/data");
co_return data;
}Tasks zusammensetzen
Wenn Sie einen Task innerhalb eines anderen abwarten, werden die beiden verkettet. Der äußere Task wird angehalten, bis der innere abgeschlossen ist.
Task<int> outer() {
int x = co_await inner_a();
int y = co_await inner_b();
co_return x + y;
}Parallele Tasks
Starten Sie für parallele asynchrone Arbeit die Tasks, ohne jeden sofort abzuwarten, und warten Sie anschließend auf alle.
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;
}Weitergabe von Ausnahmen
Ausnahmen, die innerhalb eines asynchronen Tasks ausgelöst werden, können im unhandled_exception des Promise aufgefangen und auf der Seite des Awaiters erneut ausgelöst werden.
Abbruch
Die Standardbibliothek stellt noch kein Abbruchprimitiv bereit. Bibliotheken (cppcoro, boost.cobalt) entwickeln eigene Lösungen – normalerweise mit Cancellation Tokens oder Stop Sources.
Boost.Asio-Integration
Asio unterstützt Coroutines nativ. Verwenden Sie co_await mit async_read, async_write und ähnlichen Operationen. Derzeit die sauberste Lösung für asynchrones C++-I/O.
Leistung
Das Fortsetzen einer Coroutine ist deutlich günstiger als ein Thread-Wechsel. Der Compiler nimmt häufig Teile des Zustandsautomaten per Inlining auf. Erstellen Sie ein Profil, um zu überprüfen, ob die Kette Ihrer Awaitables effizient kompiliert wird.
Zukünftige Entwicklungen
C++23 hat std::generator und weitere Verbesserungen hinzugefügt. C++26 könnte std::execution (Sender/Receiver) bringen – ein allgemeineres asynchrones Framework, das mit Coroutines zusammenarbeitet.
Kurze Überprüfung
Welche drei Methoden benötigt ein Awaitable-Typ?
Zusammenfassung
Asynchrone Tasks kombinieren co_await mit Awaitables, um asynchronen Code ohne Callbacks zu schreiben. Awaitables besitzen await_ready, await_suspend und await_resume. Bibliotheken (cppcoro, Asio) stellen fertige Task- und Awaitable-Typen bereit.
Häufig gestellte Fragen
Ist die Lektion „Asynchrone Aufgaben und Awaiter-Typen“ kostenlos?
Ja — der vollständige Text von „Asynchrone Aufgaben und Awaiter-Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Asynchrone Aufgaben und Awaiter-Typen“?
Setzen Sie asynchrone Aufgaben mit eigenen Awaiter- und Promise-Typen zusammen. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C++ Academy zu starten?
Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Asynchrone Aufgaben und Awaiter-Typen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?
Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Coroutine-Konzepte: co_await, co_yield, co_return
- Einen einfachen Generator implementieren
- Asynchrone Aufgaben und Awaiter-Typen
- Speicherzuweisung für Coroutine-Frames