Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::future_status — resultado de una espera con límite de tiempo

std::future_status es una enumeración de ámbito de <future> que devuelven wait_for() y wait_until(). Distingue un resultado listo, un tiempo de espera agotado y una ejecución diferida. El estado por sí mismo no obtiene el valor ni indica si el cálculo terminó sin una excepción.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#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 es un enum class de <future>. Los miembros wait_for() y wait_until() de std::future<T> y std::shared_future<T> devuelven este tipo. El primero recibe una duración y el segundo, un punto en el tiempo. Comprueban si el estado compartido está listo, pero no obtienen el resultado.

std::future_status::ready significa que el estado compartido contiene un valor o una excepción lista para recuperarse. No garantiza que el cálculo haya tenido éxito: get() puede volver a lanzar la excepción almacenada. std::future_status::timeout significa que la espera terminó porque se agotó el tiempo límite; no cancela la tarea ni demuestra que siga ejecutándose cuando se examina el estado.

std::future_status::deferred significa que el estado contiene una función diferida, por ejemplo, una creada con std::async(std::launch::deferred, ...). Una espera con límite de tiempo no la inicia y devuelve este estado sin esperar a que venza el límite. La primera espera sin límite, mediante wait() o get(), la ejecuta en el hilo que hace la llamada. Un bucle que solo consulta wait_for() no iniciará esa tarea.

Llama a los miembros de espera solo en un objeto con estado compartido: valid() no significa ready. En std::future<T>, llamar a get() consume el resultado y deja valid() == false; esperar después en ese objeto tiene comportamiento indefinido. El ejemplo comprueba de forma determinista los tres estados con wait_for(0ms), una promesa y una tarea explícitamente diferida, sin dormir. Las páginas citadas presentan un borrador de trabajo en evolución, no un texto C++23 congelado.

Ejemplos

#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

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes