Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

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.

Źródła