Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::shared_future — sdílený přístup k výsledku

std::shared_future umožňuje více příjemcům přistupovat ke stejnému výsledku nebo výjimce. Lze jej kopírovat a opakovaně volat get(); wait() čeká na připravenost, zatímco wait_for() ji kontroluje s časovým limitem.

Verze: C++23; repository compiler flag, production runtime not attested

Syntaxe

#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 <future> je kopírovatelný handle ke sdílenému stavu obsahujícímu výsledek nebo výjimku. Kopie odkazují na tentýž stav, nikoli na kopie výsledku. future.share() převede stav z std::future<T> do std::shared_future<T>; zdrojový objekt pak má valid() == false.

std::shared_future::get() čeká na připravenost a vrací const T&; pro std::shared_future<T&> vrací T& a pro std::shared_future<void> nevrací žádnou hodnotu. Případnou uloženou výjimku vyhodí. Na rozdíl od std::future::get() stav nespotřebuje: opakovaná volání jsou povolena. Odkaz na uloženou hodnotu se nesmí použít po zničení sdíleného stavu; referenční specializace neprodlužuje životnost odkazovaného objektu.

std::shared_future::wait() čeká na připravenost, aniž by získával výsledek nebo vyhazoval uloženou výjimku. std::shared_future::wait_for(duration) vrací std::future_status::ready, std::future_status::timeout nebo std::future_status::deferred. U odložené úlohy vrátí deferred, aniž ji spustí; wait() nebo get() ji může vykonat. Časový limit práci nezruší ani nezaručuje přesnou dobu návratu.

Tyto tři operace vyžadují valid() == true; porušení této podmínky způsobí nedefinované chování, nikoli zaručenou výjimku. V různých vláknech používejte samostatné kopie handle. Připravenost synchronizuje zveřejnění výsledku, ale následné souběžné změny dat vyžadují vlastní synchronizaci. Příklad záměrně používá jedno vlákno: ukazuje sdílený stav a opakované čtení bez závislosti na plánování.

Příklady

#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';
}

Výsledek

timeout: true
ready: true
42 42 42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje