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.