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.