Cos'è std::future in C++?

std::future — è una classe modello in C++ che rappresenta il risultato (valore o eccezione) di un'operazione asincrona, che sarà disponibile in futuro. Viene utilizzata per ottenere il risultato dell'esecuzione di un task avviato in un thread separato o tramite std::async.

Caratteristiche principali:

• Asincronia: Permette di eseguire un'operazione senza bloccare il thread corrente.
• Ottenere risultato: Il metodo get() permette di ottenere il risultato. Se il risultato non è ancora pronto, get() bloccherà il thread corrente fino a quando lo sarà o fino a quando verrà sollevata un'eccezione.
• Trasmissione dati: Associato a un oggetto std::promise, che fornisce un modo per impostare il risultato o l'eccezione.
• Stato: std::future ha uno stato che indica se il risultato è pronto. Può essere verificato con wait() o wait_for().
• Ottenimento singolo: Il metodo get() può essere chiamato una sola volta per ogni oggetto std::future.
• Tipo di risultato: Tipizzato dal tipo di valore restituito dall'operazione asincrona.

Esempio di utilizzo con std::async:

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

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

// Esempio di utilizzo di std::future con std::async
int main() {
    // Avvia un'operazione asincrona
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Esegue un'altra attività mentre l'operazione viene calcolata
    std::cout << "Facendo qualcos'altro..." << std::endl;

    // Ottieni il risultato (blocca se non pronto)
    int result = result_future.get();
    std::cout << "Risultato: " << result << std::endl;

    return 0;
}

Esempio di utilizzo con 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));
    // Imposta il risultato
    promise_obj.set_value(123);
}

// Esempio di utilizzo di std::future con std::promise
int main() {
    // Crea promise e future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Avvia un worker in un thread separato, passando il promise
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Esegue un'altra attività mentre il worker lavora
    std::cout << "Facendo qualcos'altro..." << std::endl;

    // Ottieni il risultato (blocca se non pronto)
    int result = future_obj.get();
    std::cout << "Risultato dal worker: " << result << std::endl;

    // Attende la fine del thread worker
    worker_thread.join();

    return 0;
}

Metodi importanti di std::future:

Metodo	Descrizione
get()	Ottiene il risultato. Blocca se il risultato non è ancora pronto. Può essere chiamato una sola volta.
valid()	Verifica se std::future è associato a un'operazione asincrona in corso.
wait()	Blocca il thread corrente fino a quando il risultato non è disponibile (o viene sollevata un'eccezione).
wait_for()	Attende il risultato per un intervallo di tempo specificato. Restituisce lo stato di attesa.
wait_until()	Attende il risultato fino a un momento specifico nel tempo. Restituisce lo stato di attesa.

std::future fa parte della libreria <future> e fornisce un modo comodo per gestire i risultati di calcoli asincroni, semplificando lo sviluppo di applicazioni multithread.