Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::future_status — risultato di un’attesa con limite di tempo

std::future_status è un’enumerazione con ambito definito di <future>, restituita da wait_for() e wait_until(). Distingue un risultato pronto, la scadenza del tempo limite e l’esecuzione differita. Lo stato in sé non recupera il valore e non indica se il calcolo è terminato senza eccezioni.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <future>
// Declared in namespace std:
enum class future_status { ready, timeout, deferred };
// f.wait_for(duration) and f.wait_until(time_point) return std::future_status.

std::future_status è un enum class di <future>. I membri wait_for() e wait_until() di std::future<T> e std::shared_future<T> restituiscono questo tipo. Il primo accetta una durata, il secondo un punto nel tempo. Verificano se lo stato condiviso è pronto, senza recuperare il risultato.

std::future_status::ready significa che lo stato condiviso contiene un valore o un’eccezione pronta per essere recuperata. Non garantisce che il calcolo sia riuscito: get() può rilanciare l’eccezione memorizzata. std::future_status::timeout significa che l’attesa è terminata perché il tempo limite è scaduto; non annulla l’attività e non dimostra che sia ancora in esecuzione quando si esamina lo stato.

std::future_status::deferred significa che lo stato contiene una funzione differita, per esempio creata da std::async(std::launch::deferred, ...). Un’attesa con limite di tempo non la avvia e restituisce questo stato senza attendere la scadenza. La prima attesa senza limite, tramite wait() o get(), la esegue nel thread chiamante. Un ciclo che interroga solo wait_for() non avvierà tale attività.

Chiama i membri di attesa solo su un oggetto con uno stato condiviso: valid() non significa ready. Per std::future<T>, chiamare get() consuma il risultato e lascia valid() == false; attendere ancora su quell’oggetto ha comportamento indefinito. L’esempio verifica in modo deterministico tutti e tre gli stati con wait_for(0ms), una promise e un’attività esplicitamente differita, senza sospendere il thread. Le pagine citate presentano una bozza di lavoro in evoluzione, non un testo C++23 congelato.

Esempi

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

int main() {
    using namespace std::chrono_literals;
    std::cout << std::boolalpha;

    std::promise<int> producer;
    auto result = producer.get_future();
    std::cout << "timeout: "
              << (result.wait_for(0ms) == std::future_status::timeout) << '\n';

    producer.set_value(42);
    std::cout << "ready: "
              << (result.wait_for(0ms) == std::future_status::ready) << '\n';

    auto lazy = std::async(std::launch::deferred, [] { return 7; });
    std::cout << "deferred: "
              << (lazy.wait_for(0ms) == std::future_status::deferred) << '\n';

    std::cout << "values: " << result.get() << ' ' << lazy.get() << '\n';
}

Risultato

timeout: true
ready: true
deferred: true
values: 42 7

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti