Wat is std::future in C++?

std::future — is een sjabloonklasse in C++ die het resultaat (waarde of uitzondering) van een asynchrone operatie voorstelt, dat in de toekomst beschikbaar zal zijn. Het wordt gebruikt om het resultaat van een taak die in een aparte thread of via std::async is gestart, op te halen.

Belangrijke kenmerken:

• Asynchroon: Maakt het mogelijk om een operatie uit te voeren zonder de huidige thread te blokkeren.
• Resultaat ophalen: De methode get() maakt het mogelijk om het resultaat op te halen. Als het resultaat nog niet klaar is, zal get() de huidige thread blokkeren totdat het klaar is of totdat er een uitzondering wordt gegooid.
• Gegevensoverdracht: Geassocieerd met een std::promise object, dat een manier biedt om het resultaat of de uitzondering in te stellen.
• Toestand: std::future heeft een toestand die aangeeft of het resultaat klaar is. Dit kan worden gecontroleerd met wait() of wait_for().
• Eénmalig ophalen: De methode get() mag slechts één keer worden aangeroepen voor elk std::future object.
• Resultaattype: Getypeerd door het type van de waarde dat door de asynchrone operatie wordt geretourneerd.

Voorbeeld met std::async:

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

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

// Voorbeeld van gebruik van std::future met std::async
int main() {
    // Start een asynchrone operatie
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Voer een andere taak uit terwijl de operatie wordt berekend
    std::cout << "Iets anders doen..." << std::endl;

    // Haal het resultaat op (blokkeert indien nog niet klaar)
    int result = result_future.get();
    std::cout << "Resultaat is: " << result << std::endl;

    return 0;
}

Voorbeeld met 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));
    // Stel het resultaat in
    promise_obj.set_value(123);
}

// Voorbeeld van gebruik van std::future met std::promise
int main() {
    // Maak een promise en future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Start een worker in een aparte thread, geef de promise door
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Voer een andere taak uit terwijl de worker werkt
    std::cout << "Iets anders doen..." << std::endl;

    // Haal het resultaat op (blokkeert indien nog niet klaar)
    int result = future_obj.get();
    std::cout << "Resultaat van worker: " << result << std::endl;

    // Wacht tot de worker thread klaar is
    worker_thread.join();

    return 0;
}

Belangrijke methoden van std::future:

Methode	Beschrijving
get()	Haalt het resultaat op. Blokkeert indien nog niet klaar. Kan slechts één keer worden aangeroepen.
valid()	Controleert of std::future verbonden is met een lopende asynchrone operatie.
wait()	Blokkeert de huidige thread totdat het resultaat beschikbaar is (of een uitzondering wordt gegooid).
wait_for()	Wacht op het resultaat voor een gespecificeerde tijdsduur. Geeft de wachstatus terug.
wait_until()	Wacht op het resultaat tot een specifiek tijdstip. Geeft de wachstatus terug.

std::future maakt deel uit van de <future> bibliotheek en biedt een handige manier om de resultaten van asynchrone berekeningen te beheren, wat het ontwikkelen van multithread applicaties vereenvoudigt.