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

CKTIS / C++

std::shared_future — acesso partilhado a um resultado

std::shared_future permite que vários consumidores acedam ao mesmo resultado ou exceção. É copiável e permite chamadas repetidas a get(); wait() aguarda que esteja pronto, enquanto wait_for() verifica essa disponibilidade com um limite de tempo.

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

Sintaxe

#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> é um identificador copiável para um estado partilhado que contém um resultado ou uma exceção. As cópias referem-se ao mesmo estado, não a cópias do resultado. future.share() transfere o estado de std::future<T> para std::shared_future<T>; o objeto de origem fica então com valid() == false.

std::shared_future::get() aguarda que o resultado esteja pronto e devolve const T&; para std::shared_future<T&>, devolve T&, e para std::shared_future<void> não devolve qualquer valor. Lança a exceção armazenada, se existir. Ao contrário de std::future::get(), não consome o estado: são permitidas chamadas repetidas. Não se deve usar uma referência ao valor armazenado depois de o estado partilhado ser destruído; a especialização de referência não prolonga a duração do objeto referenciado.

std::shared_future::wait() aguarda que o resultado esteja pronto sem o obter nem lançar a exceção armazenada. std::shared_future::wait_for(duration) devolve std::future_status::ready, std::future_status::timeout ou std::future_status::deferred. Para uma tarefa adiada, devolve deferred sem a iniciar; wait() ou get() pode executá-la. Um limite de tempo não cancela o trabalho nem garante um tempo de retorno estrito.

Estas três operações exigem valid() == true; a violação desta condição causa comportamento indefinido, não uma exceção garantida. Use cópias distintas do identificador em threads diferentes. A disponibilidade sincroniza a publicação do resultado, mas modificações concorrentes posteriores dos dados requerem sincronização própria. O exemplo usa deliberadamente uma única thread: demonstra o estado partilhado e leituras repetidas sem dependência do escalonamento.

Exemplos

#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

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