0Pricing
C++ Academy · Lektion

Grundlagen von std::async und std::future

Führen Sie Aufgaben asynchron aus und rufen Sie ihre Ergebnisse über std::future ab.

Grundlagen von std::async und std::future ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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 Aufgaben

std::async führt eine Funktion asynchron aus und gibt ein std::future zurück, das das Ergebnis liefert. Dies ist eine Abstraktion auf höherer Ebene als die manuelle Verwaltung von Threads.

Grundlegende Verwendung

Übergeben Sie eine aufrufbare Einheit und Argumente. std::async gibt ein std::future<Result> zurück.

#include <future>

int compute() { return 42; }

std::future<int> f = std::async(compute);
int result = f.get();   // blocks until done

Startstrategien

Das erste Argument legt fest, wann die Aufgabe ausgeführt wird:

  • std::launch::async – sofort einen neuen Thread starten
  • std::launch::deferred – synchron bei get() ausführen
  • Standard (keine Strategie) – die Implementierung entscheidet
auto f = std::async(std::launch::async, compute);

Methoden von std::future

Häufig verwendete Operationen:

  • get() – blockiert bis zum Abschluss und gibt das Ergebnis zurück (nur einmal möglich)
  • wait() – blockiert, gibt das Ergebnis aber nicht zurück
  • wait_for(d) / wait_until(t) – zeitgesteuertes Warten
  • valid() – wurde dieses Future eingerichtet?

Weitergabe von Ausnahmen

Wenn die asynchrone Aufgabe eine Ausnahme auslöst, wird diese im Future gespeichert und bei get() erneut ausgelöst.

auto f = std::async([] { throw std::runtime_error("oops"); });
try {
    f.get();
} catch (const std::exception& e) {
    std::cout << e.what();
}

Mehrere Werte zurückgeben

Verpacken Sie das Ergebnis in einem Tupel, einer Struktur oder einem Container.

auto f = std::async([] {
    return std::make_pair(42, std::string("hello"));
});
auto [n, s] = f.get();

Mehrere Aufgaben parallel

Starten Sie mehrere asynchrone Aufgaben und warten Sie auf alle.

auto a = std::async(work_a);
auto b = std::async(work_b);
auto c = std::async(work_c);

std::cout << a.get() + b.get() + c.get();

std::promise: Manuelles Future

Verwenden Sie bei Producer-Consumer-Mustern std::promise, wenn der Consumer ein Future benötigt, der Producer sich aber in einem anderen Thread befindet.

std::promise<int> p;
std::future<int> f = p.get_future();

std::thread t([&p] { p.set_value(42); });
std::cout << f.get();
t.join();

std::packaged_task

Verknüpft eine aufrufbare Einheit mit einem Future. Nützlich, wenn die Aufgabe an anderer Stelle aufgerufen wird, etwa in einem Thread-Pool.

shared_future

Ein std::future kann nur einmal gelesen werden. std::shared_future ermöglicht mehrere Leser – nützlich, um ein Ergebnis zu verteilen.

Verhalten des Destruktors

Der Destruktor eines von std::async mit der Standardstrategie zurückgegebenen Futures kann blockieren, bis die Aufgabe abgeschlossen ist. Beachten Sie dies bei lang laufenden Aufgaben.

Über std::async hinaus

Für asynchrone Verarbeitung in produktionsreifen Anwendungen sollten Sie Bibliotheken wie Boost.Asio oder Folly sowie die C++20/23-Executors und Coroutines in Betracht ziehen. std::async ist ein Ausgangspunkt.

Kurze Überprüfung

Was bewirkt der Aufruf von .get() für ein std::future?

Zusammenfassung

std::async führt eine Funktion asynchron aus; das zurückgegebene std::future liefert das Ergebnis und gibt Ausnahmen weiter. Verwenden Sie Startstrategien, um die Ausführung zu steuern. Für komplexe Muster verwenden Sie std::promise und std::packaged_task.

Häufig gestellte Fragen

Ist die Lektion „Grundlagen von std::async und std::future“ kostenlos?

Ja — der vollständige Text von „Grundlagen von std::async und std::future“ 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 „Grundlagen von std::async und std::future“?

Führen Sie Aufgaben asynchron aus und rufen Sie ihre Ergebnisse über std::future ab. 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 4 von 4.

Wie lange dauert die Lektion „Grundlagen von std::async und std::future“?

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

  1. std::thread: Zusammenführen und Loslösen
  2. std::mutex, lock_guard und unique_lock
  3. Bedingungsvariablen und Arbeitermuster
  4. Grundlagen von std::async und std::future
← Zurück zu C++ Academy