Ce este std::future în C++?

std::future — acesta este un șablon de clasă în C++, reprezentând rezultatul (valoare sau excepție) al unei operații asincrone, care va fi disponibil în viitor. Este utilizat pentru a obține rezultatul execuției unei sarcini lansate într-un fir de execuție separat sau prin std::async.

Caracteristici cheie:

• Asincronie: Permite executarea unei operații fără a bloca firul curent.
• Obținerea rezultatului: Metoda get() permite obținerea rezultatului operației. Dacă rezultatul nu este încă gata, get() va bloca firul curent până când acesta devine disponibil sau până când se aruncă o excepție.
• Transfer de date: Se leagă de obiectul std::promise, care oferă o modalitate de a stabili rezultatul sau excepția.
• Stare: std::future are o stare care indică dacă rezultatul este gata. Se poate verifica cu wait() sau wait_for().
• Obținere unică: Metoda get() poate fi apelată o singură dată pentru fiecare obiect std::future.
• Tipul rezultatului: Tipizat cu tipul valorii returnate de operația asincronă.

Exemplu de utilizare cu std::async:

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

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

// Exemplu de utilizare a std::future cu std::async
int main() {
    // Începem o operație asincronă
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Executăm altă muncă în timp ce operația se calculează
    std::cout << "Doing something else..." << std::endl;

    // Obținem rezultatul (blochează dacă nu este gata)
    int result = result_future.get();
    std::cout << "Result is: " << result << std::endl;

    return 0;
}

Exemplu de utilizare cu 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));
    // Setăm rezultatul
    promise_obj.set_value(123);
}

// Exemplu de utilizare a std::future cu std::promise
int main() {
    // Creăm promise și future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Începem worker-ul într-un fir de execuție separat, transmitând promise
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Executăm altă muncă în timp ce worker-ul rulează
    std::cout << "Doing something else..." << std::endl;

    // Obținem rezultatul (blochează dacă nu este gata)
    int result = future_obj.get();
    std::cout << "Result from worker: " << result << std::endl;

    // Așteptăm finalizarea firului worker
    worker_thread.join();

    return 0;
}

Metode importante ale std::future:

Metodă	Descriere
get()	Obține rezultatul. Blochează dacă rezultatul nu este încă disponibil. Poate fi apelată o singură dată.
valid()	Verifică dacă std::future este asociat cu o stare de operație asincronă.
wait()	Blochează firul curent până când rezultatul devine disponibil (sau se aruncă o excepție).
wait_for()	Așteaptă rezultatul pentru intervalul de timp specificat. Returnează statutul așteptării.
wait_until()	Așteaptă rezultatul până la momentul specificat. Returnează statutul așteptării.

std::future face parte din biblioteca <future> și oferă o modalitate convenabilă de a gestiona rezultatele calculului asincron, simplificând dezvoltarea aplicațiilor multi-thread.