Asynchrone Programmierung in C++: Vollständiger Leitfaden für Anfänger

Einführung in die asynchrone Programmierung mit C++

Moderne Anwendungen erfordern zunehmend hohe Leistung und Reaktionsfähigkeit. Asynchrone Programmierung in C++ ist ein leistungsstarkes Werkzeug, das es ermöglicht, mehrere Aufgaben gleichzeitig auszuführen, ohne den Hauptausführungs-Thread zu blockieren. In diesem Leitfaden erläutern wir die Grundlagen der Asynchronität in C++: von klassischen Ansätzen bis hin zu modernen Coroutinen (coroutines), die mit dem Standard C++20 hinzugefügt wurden.

Wenn Sie neu in C++ sind, aber bereits mit der grundlegenden Syntax vertraut sind, hilft Ihnen dieser Artikel zu verstehen, wie Sie Ihr Programm mehrere Dinge gleichzeitig erledigen lassen. Wir betrachten praktische Beispiele, die Sie sofort in Ihren eigenen Projekten anwenden können.

Grundlegende Konzepte und warum dies notwendig ist

In der traditionellen synchronen Programmierung wird Code streng sequenziell ausgeführt: Ein Vorgang wird abgeschlossen, dann beginnt der nächste. Das ist einfach, aber ineffizient, wenn das Programm auf Ein-/Ausgabe wartet (Datei lesen, Netzwerkanfrage) oder schwere Berechnungen durchführt.

Asynchrone Programmierung löst dieses Problem, indem sie Folgendes ermöglicht:

• Den Haupt-Thread nicht blockieren — die Anwendungsoberfläche bleibt reaktionsfähig.
• Die Ausführung beschleunigen — parallele Datenverarbeitung auf Mehrkernprozessoren.
• Ressourcen effizient nutzen — während eine Aufgabe auf Daten wartet, kann eine andere ausgeführt werden.

In C++ gibt es mehrere Möglichkeiten, Asynchronität zu implementieren: von niedrigstufigen Threads (std::thread) bis hin zu hochstufigen Abstraktionen (std::async, std::future und Coroutinen).

1. Asynchronität mit std::async und std::future

Der einfachste Weg, eine asynchrone Aufgabe in C++ zu starten, ist die Verwendung der Funktion std::async aus der Header-Datei <future>. Sie gibt ein Objekt std::future zurück, das das Ergebnis der Ausführung speichert.

Basisbeispiel

#include <iostream>#include <future>#include <thread>#include <chrono>

// Funktion, die asynchron ausgeführt werden sollint slow_calculation(int x) {    std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulation langer Arbeit    return x * x;}

int main() {    std::cout << "Asynchrone Aufgabe wird gestartet..." << std::endl;        // Starte slow_calculation in einem separaten Thread    std::future<int> result = std::async(std::launch::async, slow_calculation, 5);        std::cout << "Haupt-Thread arbeitet weiter..." << std::endl;        // Ergebnis abrufen (blockiert den Thread, falls die Aufgabe noch nicht abgeschlossen ist)    int value = result.get();    std::cout << "Ergebnis: " << value << std::endl; // Ausgabe: 25        return 0;}

In diesem Beispiel startet std::async die Funktion in einem separaten Thread. Während sie ausgeführt wird, gibt der Haupt-Thread eine Nachricht aus. Die Methode get() wartet auf den Abschluss der Aufgabe und gibt das Ergebnis zurück.

Startrichtlinien

std::async hat zwei Modi:

• std::launch::async — die Aufgabe wird garantiert in einem neuen Thread ausgeführt.
• std::launch::deferred — die Aufgabe wird verzögert ausgeführt, nur beim Aufruf von get() oder wait() im selben Thread.

2. Promises und Futures: manuelle Verwaltung

Wenn Sie eine flexiblere Verwaltung asynchroner Aufgaben benötigen, verwenden Sie das Paar std::promise und std::future. promise ermöglicht es, einen Wert oder eine Ausnahme in einem Thread zu setzen, und future, ihn in einem anderen zu empfangen.

Beispiel mit promise

#include <iostream>#include <future>#include <thread>

void worker(std::promise<int> prom, int a, int b) {    try {        int result = a / b; // Kann
```