O que é std::future em C++?

std::future — é uma classe modelo em C++ que representa o resultado (valor ou exceção) de uma operação assíncrona, que estará disponível no futuro. É usado para obter o resultado da execução de uma tarefa iniciada numa thread separada ou através de std::async.

Características principais:

• Assincronismo: Permite realizar uma operação sem bloquear a thread atual.
• Obter resultado: O método get() permite obter o resultado. Se o resultado ainda não estiver pronto, get() bloqueará a thread atual até que esteja ou até que uma exceção seja lançada.
• Transferência de dados: Associado a um objeto std::promise, que fornece uma forma de definir o resultado ou a exceção.
• Estado: std::future tem um estado que indica se o resultado está pronto. Pode ser verificado com wait() ou wait_for().
• Obtenção única: O método get() só pode ser chamado uma vez por cada objeto std::future.
• Tipo de resultado: Tipado pelo tipo de valor retornado pela operação assíncrona.

Exemplo de uso com std::async:

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

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

// Exemplo de uso de std::future com std::async
int main() {
    // Inicia uma operação assíncrona
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Realiza outra tarefa enquanto a operação é calculada
    std::cout << "A fazer algo mais..." << std::endl;

    // Obtém o resultado (bloqueia se não estiver pronto)
    int result = result_future.get();
    std::cout << "Resultado é: " << result << std::endl;

    return 0;
}

Exemplo de uso com 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));
    // Define o resultado
    promise_obj.set_value(123);
}

// Exemplo de uso de std::future com std::promise
int main() {
    // Cria promise e future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Inicia um worker numa thread separada, passando o promise
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Realiza outra tarefa enquanto o worker trabalha
    std::cout << "A fazer algo mais..." << std::endl;

    // Obtém o resultado (bloqueia se não estiver pronto)
    int result = future_obj.get();
    std::cout << "Resultado do worker: " << result << std::endl;

    // Espera que o worker termine
    worker_thread.join();

    return 0;
}

Métodos importantes de std::future:

Método	Descrição
get()	Obtém o resultado. Bloqueia se o resultado ainda não estiver pronto. Pode ser chamado apenas uma vez.
valid()	Verifica se std::future está associado a uma operação assíncrona em curso.
wait()	Bloqueia o thread atual até que o resultado esteja disponível (ou uma exceção seja lançada).
wait_for()	Aguarda o resultado durante um intervalo de tempo especificado. Retorna o estado de espera.
wait_until()	Aguarda o resultado até um momento específico no tempo. Retorna o estado de espera.

std::future faz parte da biblioteca <future> e fornece uma maneira conveniente de gerenciar os resultados de cálculos assíncronos, simplificando o desenvolvimento de aplicações multithread.