¿Qué es std::future en C++?

std::future — es una clase plantilla en C++ que representa el resultado (valor o excepción) de una operación asíncrona, que estará disponible en el futuro. Se utiliza para obtener el resultado de una tarea ejecutada en un hilo separado o mediante std::async.

Características clave:

• Asincronía: Permite realizar una operación sin bloquear el hilo actual.
• Obtener resultado: El método get() permite obtener el resultado de la operación. Si el resultado aún no está listo, get() bloqueará el hilo actual hasta que esté listo o hasta que se lance una excepción.
• Transferencia de datos: Se asocia con un objeto std::promise, que proporciona una forma de establecer el resultado o la excepción.
• Estado: std::future tiene un estado que indica si el resultado está listo. Se puede comprobar con wait() o wait_for().
• Obtención única: El método get() solo puede llamarse una vez por cada objeto std::future.
• Tipo de resultado: Tipado por el tipo de valor devuelto por la operación asíncrona.

Ejemplo de uso con std::async:

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

int calculate_something() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
}

// Ejemplo de uso de std::future con std::async
int main() {
    // Inicia una operación asíncrona
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Realiza otra tarea mientras la operación se calcula
    std::cout << "Haciendo otra cosa..." << std::endl;

    // Obtiene el resultado (bloquea si no está listo)
    int result = result_future.get();
    std::cout << "El resultado es: " << result << std::endl;

    return 0;
}

Ejemplo de uso con std::promise:

#include <future>
#include <thread>
#include <iostream>

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // Establece el resultado
    promise_obj.set_value(123);
}

// Ejemplo de uso de std::future con std::promise
int main() {
    // Crea promise y future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Inicia un worker en un hilo separado, pasando el promise
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Realiza otra tarea mientras el worker trabaja
    std::cout << "Haciendo otra cosa..." << std::endl;

    // Obtiene el resultado (bloquea si no está listo)
    int result = future_obj.get();
    std::cout << "Resultado del worker: " << result << std::endl;

    // Espera a que termine el hilo worker
    worker_thread.join();

    return 0;
}

Métodos importantes de std::future:

Método	Descripción
get()	Obtiene el resultado. Bloquea si el resultado aún no está listo. Solo puede ser llamado una vez.
valid()	Verifica si std::future está asociado con una operación asíncrona en curso.
wait()	Bloquea el hilo actual hasta que el resultado esté disponible (o se lance una excepción).
wait_for()	Espera el resultado durante un intervalo de tiempo especificado. Retorna el estado de espera.
wait_until()	Espera el resultado hasta un momento específico en el tiempo. Retorna el estado de espera.

std::future forma parte de la biblioteca <future> y proporciona una forma conveniente de gestionar los resultados de cálculos asíncronos, simplificando el desarrollo de aplicaciones multihilo.