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

CKTIS / C++

std::shared_future — acceso compartido a un resultado

std::shared_future permite que varios consumidores accedan a un mismo resultado o excepción. Se puede copiar y admite llamadas repetidas a get(); wait() espera a que esté listo, mientras que wait_for() comprueba si lo está con un límite de tiempo.

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

Sintaxis

#include <chrono>
#include <future>
std::shared_future<T> sf = future.share();
const T& value = sf.get(); // primary template
sf.wait();
std::future_status status = sf.wait_for(std::chrono::milliseconds{0});

std::shared_future<T> de <future> es un identificador copiable a un estado compartido que contiene un resultado o una excepción. Las copias se refieren al mismo estado, no a copias del resultado. future.share() transfiere el estado de std::future<T> a std::shared_future<T>; después, el objeto de origen tiene valid() == false.

std::shared_future::get() espera a que el resultado esté listo y devuelve const T&; para std::shared_future<T&> devuelve T&, y para std::shared_future<void> no devuelve ningún valor. Lanza la excepción almacenada, si la hay. A diferencia de std::future::get(), no consume el estado: se permiten llamadas repetidas. No se debe usar una referencia al valor almacenado después de que se destruya el estado compartido; la especialización de referencia no prolonga la vida del objeto referido.

std::shared_future::wait() espera a que el resultado esté listo sin recuperarlo ni lanzar la excepción almacenada. std::shared_future::wait_for(duration) devuelve std::future_status::ready, std::future_status::timeout o std::future_status::deferred. Para una tarea diferida, devuelve deferred sin iniciarla; wait() o get() pueden ejecutarla. Un tiempo límite no cancela el trabajo ni garantiza un tiempo de retorno estricto.

Estas tres operaciones requieren valid() == true; incumplir esta condición provoca comportamiento indefinido, no una excepción garantizada. Usa copias distintas del identificador en hilos diferentes. La disponibilidad sincroniza la publicación del resultado, pero las modificaciones concurrentes posteriores de los datos necesitan su propia sincronización. El ejemplo usa deliberadamente un solo hilo: muestra el estado compartido y las lecturas repetidas sin depender de la planificación.

Ejemplos

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

int main() {
    std::promise<int> producer;
    std::shared_future<int> first = producer.get_future().share();
    auto second = first;

    const auto before = first.wait_for(std::chrono::milliseconds{0});
    producer.set_value(42);
    second.wait();
    const auto after = second.wait_for(std::chrono::milliseconds{0});

    std::cout << std::boolalpha;
    std::cout << "timeout: " << (before == std::future_status::timeout) << '\n';
    std::cout << "ready: " << (after == std::future_status::ready) << '\n';
    std::cout << first.get() << ' ' << second.get() << ' ' << first.get() << '\n';
}

Resultado

timeout: true
ready: true
42 42 42

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