Was ist std::future in C++?

std::future — ist eine Template-Klasse in C++, die das Ergebnis (Wert oder Ausnahme) einer asynchronen Operation darstellt, die in Zukunft verfügbar sein wird. Sie wird verwendet, um das Ergebnis einer Aufgabe zu erhalten, die in einem separaten Thread oder mittels std::async gestartet wurde.

Wichtige Merkmale:

• Asynchronität: Ermöglicht die Ausführung einer Operation, ohne den aktuellen Thread zu blockieren.
• Ergebnis erhalten: Die Methode get() ermöglicht das Abrufen des Ergebnisses. Wenn das Ergebnis noch nicht bereit ist, blockiert get() den aktuellen Thread, bis es bereit ist oder eine Ausnahme ausgelöst wird.
• Datenübertragung: Wird mit einem Objekt std::promise verbunden, das eine Möglichkeit bietet, das Ergebnis oder eine Ausnahme festzulegen.
• Zustand: std::future hat einen Zustand, der angibt, ob das Ergebnis bereit ist. Kann mit wait() oder wait_for() überprüft werden.
• Einmaliger Zugriff: Die Methode get() kann nur einmal für jedes std::future-Objekt aufgerufen werden.
• Ergebnis-Typ: Wird durch den Rückgabetyp der asynchronen Operation typisiert.

Beispiel mit std::async:

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

int calculate_something() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
}

// Beispiel für die Verwendung von std::future mit std::async
int main() {
    // Startet eine asynchrone Operation
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Führt eine andere Arbeit aus, während die Operation berechnet wird
    std::cout << "Etwas anderes machen..." << std::endl;

    // Holt das Ergebnis (blockiert, wenn es noch nicht fertig ist)
    int result = result_future.get();
    std::cout << "Ergebnis ist: " << result << std::endl;

    return 0;
}

Beispiel mit std::promise:

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

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // Setzt das Ergebnis
    promise_obj.set_value(123);
}

// Beispiel für die Verwendung von std::future mit std::promise
int main() {
    // Erstellen eines promise und eines future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Startet einen Worker in einem separaten Thread, der das promise erhält
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Führt eine andere Arbeit aus, während der Worker arbeitet
    std::cout << "Etwas anderes machen..." << std::endl;

    // Holt das Ergebnis (blockiert, wenn es noch nicht fertig ist)
    int result = future_obj.get();
    std::cout << "Ergebnis vom Worker: " << result << std::endl;

    // Wartet auf das Ende des Worker-Threads
    worker_thread.join();

    return 0;
}

Wichtige Methoden von std::future:

Methode	Beschreibung
get()	Holt das Ergebnis. Blockiert, wenn das Ergebnis noch nicht bereit ist. Kann nur einmal aufgerufen werden.
valid()	Prüft, ob std::future mit einer laufenden asynchronen Operation verbunden ist.
wait()	Blockiert den aktuellen Thread, bis das Ergebnis verfügbar ist (oder eine Ausnahme ausgelöst wird).
wait_for()	Wartet auf das Ergebnis für eine angegebene Zeitspanne. Gibt den Wartezustand zurück.
wait_until()	Wartet auf das Ergebnis bis zu einem bestimmten Zeitpunkt. Gibt den Wartezustand zurück.

std::future ist Teil der <future>-Bibliothek und bietet eine bequeme Möglichkeit, die Ergebnisse asynchroner Berechnungen zu verwalten, was die Entwicklung von Multithread-Anwendungen vereinfacht.