CKTIS / C++
std::shared_future — accesso condiviso a un risultato
std::shared_future consente a più destinatari di accedere allo stesso risultato o alla stessa eccezione. È copiabile e permette chiamate ripetute a get(); wait() attende che sia pronto, mentre wait_for() ne verifica la disponibilità entro un limite di tempo.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#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> di <future> è un handle copiabile a uno stato condiviso che contiene un risultato o un’eccezione. Le copie fanno riferimento allo stesso stato, non a copie del risultato. future.share() trasferisce lo stato da std::future<T> a std::shared_future<T>; l’oggetto sorgente ha quindi valid() == false.
std::shared_future::get() attende che il risultato sia pronto e restituisce const T&; per std::shared_future<T&> restituisce T&, mentre per std::shared_future<void> non restituisce alcun valore. Se presente, lancia l’eccezione memorizzata. A differenza di std::future::get(), non consuma lo stato: sono consentite chiamate ripetute. Non si deve usare un riferimento al valore memorizzato dopo la distruzione dello stato condiviso; la specializzazione per riferimento non prolunga la durata dell’oggetto referenziato.
std::shared_future::wait() attende che il risultato sia pronto senza recuperarlo né lanciare l’eccezione memorizzata. std::shared_future::wait_for(duration) restituisce std::future_status::ready, std::future_status::timeout oppure std::future_status::deferred. Per un’attività differita restituisce deferred senza avviarla; wait() o get() possono eseguirla. Un timeout non annulla il lavoro e non garantisce un tempo di ritorno rigoroso.
Queste tre operazioni richiedono valid() == true; violare questa condizione causa comportamento indefinito, non un’eccezione garantita. Usa copie distinte dell’handle in thread diversi. La disponibilità sincronizza la pubblicazione del risultato, ma successive modifiche concorrenti ai dati richiedono una sincronizzazione propria. L’esempio usa intenzionalmente un solo thread: mostra lo stato condiviso e le letture ripetute senza dipendere dalla pianificazione.
Esempi
#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';
}
Risultato
timeout: true ready: true 42 42 42
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.