Mi az a std::future C++-ban?

std::future — ez egy sablonosztály C++-ben, amely egy aszinkron művelet eredményét (érték vagy kivétel) képviseli, amely a jövőben lesz elérhető. Használható egy külön szálon vagy std::async segítségével indított feladat végrehajtásának eredményének megszerzésére.

Fő jellemzők:

• Aszinkronitás: Lehetővé teszi egy művelet végrehajtását anélkül, hogy blokkolná a jelenlegi szálat.
• Eredmény megszerzése: A get() metódus lehetővé teszi az eredmény megszerzését. Ha az eredmény még nem elérhető, a get() blokkolni fog, amíg az rendelkezésre nem áll vagy kivétel nem keletkezik.
• Adatok átadása: A std::promise objektumhoz kapcsolódik, amely lehetővé teszi az eredmény vagy kivétel beállítását.
• Állapot: A std::future rendelkezik egy állapottal, amely megmutatja, hogy az eredmény elérhető-e. Ellenőrizhető a wait() vagy wait_for() segítségével.
• Csak egyszeri lekérés: A get() metódus minden std::future objektumnál csak egyszer hívható meg.
• Eredmény típusa: Az aszinkron művelet visszatérési értékének típusával van típusosítva.

Példa a std::async használatára:

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

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

// Példa a `std::future` használatára `std::async`-szal
int main() {
    // Aszinkron művelet indítása
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Más munka végzése, amíg a művelet számít
    std::cout << "Doing something else..." << std::endl;

    // Eredmény megszerzése (blokkol, ha még nem kész)
    int result = result_future.get();
    std::cout << "Result is: " << result << std::endl;

    return 0;
}

Példa a std::promise használatára:

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

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // Eredmény beállítása
    promise_obj.set_value(123);
}

// Példa a `std::future`-re `std::promise`-szal
int main() {
    // Promise és future létrehozása
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Worker indítása külön szálon, promise átadása
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Más munka végzése, amíg a worker fut
    std::cout << "Doing something else..." << std::endl;

    // Eredmény megszerzése (blokkol, ha még nem kész)
    int result = future_obj.get();
    std::cout << "Result from worker: " << result << std::endl;

    // Várakozás a worker szál befejezésére
    worker_thread.join();

    return 0;
}

Fontos std::future metódusok:

Metódus	Leírás
get()	Az eredmény megszerzése. Blokkol, ha az még nem elérhető. Csak egyszer hívható meg.
valid()	Ellenőrzi, hogy a std::future kapcsolódik-e egy aszinkron művelethez.
wait()	Blokkolja a jelenlegi szálat, amíg az eredmény elérhető nem lesz (vagy kivétel keletkezik).
wait_for()	Várakozik az eredményre a megadott időintervallumon belül. Visszatér a várakozás állapotával.
wait_until()	Várakozik az eredményre a megadott időpontig. Visszatér a várakozás állapotával.

A std::future a <future> könyvtár része, és kényelmes módot kínál az aszinkron számítások eredményeinek kezelésére, megkönnyítve a több szálas alkalmazások fejlesztését.