Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::future_status — resultado de uma espera com limite de tempo

std::future_status é uma enumeração com âmbito definido de <future>, devolvida por wait_for() e wait_until(). Distingue um resultado pronto, o fim do tempo limite e uma execução diferida. O estado, por si só, não obtém o valor nem indica se o cálculo terminou sem exceção.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#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 é um enum class de <future>. Os membros wait_for() e wait_until() de std::future<T> e std::shared_future<T> devolvem este tipo. O primeiro recebe uma duração; o segundo, um ponto no tempo. Verificam se o estado partilhado está pronto, sem obter o resultado.

std::future_status::ready significa que o estado partilhado contém um valor ou uma exceção pronta a ser obtida. Não garante que o cálculo tenha sido bem-sucedido: get() pode voltar a lançar a exceção armazenada. std::future_status::timeout significa que a espera terminou porque o tempo limite expirou; não cancela a tarefa nem prova que esta ainda esteja a decorrer quando examina o estado.

std::future_status::deferred significa que o estado contém uma função diferida, por exemplo, criada por std::async(std::launch::deferred, ...). Uma espera com limite de tempo não a inicia e devolve este estado sem aguardar pelo fim do limite. A primeira espera sem limite, através de wait() ou get(), executa-a na thread que fez a chamada. Um ciclo que apenas consulta wait_for() não iniciará essa tarefa.

Chame os membros de espera apenas num objeto com um estado partilhado: valid() não significa ready. Para std::future<T>, chamar get() consome o resultado e deixa valid() == false; esperar depois nesse objeto tem comportamento indefinido. O exemplo verifica deterministicamente os três estados com wait_for(0ms), uma promise e uma tarefa explicitamente diferida, sem adormecer a thread. As páginas citadas apresentam um projeto de trabalho em evolução, não um texto C++23 congelado.

Exemplos

#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';
}

Resultado

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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes