CKTIS / C++
std::shared_future — współdzielony dostęp do wyniku
std::shared_future pozwala wielu odbiorcom korzystać z jednego wyniku lub wyjątku. Można go kopiować i wielokrotnie wywoływać get(); wait() czeka na gotowość, a wait_for() sprawdza ją z limitem czasu.
Wersja: C++23; repository compiler flag, production runtime not attested
Składnia
#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> z nagłówka <future> jest kopiowalnym uchwytem do wspólnego stanu zawierającego wynik lub wyjątek. Kopie wskazują ten sam stan, a nie kopie wyniku. future.share() przenosi stan z std::future<T> do std::shared_future<T>; źródłowy obiekt ma potem valid() == false.
std::shared_future::get() czeka na gotowość i zwraca const T&; dla std::shared_future<T&> zwraca T&, a dla std::shared_future<void> nie zwraca wartości. Zgłasza zapisany wyjątek, jeśli taki istnieje. W przeciwieństwie do std::future::get() nie zużywa stanu: można wywoływać go wielokrotnie. Referencja do przechowywanej wartości nie może być używana po zniszczeniu wspólnego stanu; specjalizacja referencyjna nie przedłuża życia wskazywanego obiektu.
std::shared_future::wait() czeka na gotowość bez pobierania wyniku ani zgłaszania zapisanego wyjątku. std::shared_future::wait_for(duration) zwraca std::future_status::ready, std::future_status::timeout lub std::future_status::deferred. Dla odroczonego zadania zwraca deferred bez uruchamiania go; wait() lub get() może je wykonać. Limit czasu nie anuluje pracy i nie stanowi ścisłej gwarancji czasu powrotu.
Przed tymi trzema operacjami wymagane jest valid() == true; naruszenie tego warunku powoduje niezdefiniowane zachowanie, nie gwarantowany wyjątek. W różnych wątkach używaj osobnych kopii uchwytu. Gotowość synchronizuje udostępnienie wyniku, ale późniejsze współbieżne modyfikacje danych wymagają własnej synchronizacji. Przykład celowo używa jednego wątku: pokazuje wspólny stan i powtarzalny odczyt bez zależności od harmonogramu.
Przykłady
#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';
}
Wynik
timeout: true ready: true 42 42 42
Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.