Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

std::shared_future — zdieľaný prístup k výsledku

std::shared_future umožňuje viacerým príjemcom pristupovať k tomu istému výsledku alebo výnimke. Dá sa kopírovať a možno opakovane volať get(); wait() čaká na pripravenosť, zatiaľ čo wait_for() ju kontroluje s časovým limitom.

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

Syntax

#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írovateľný handle k zdieľanému stavu obsahujúcemu výsledok alebo výnimku. Kópie odkazujú na ten istý stav, nie na kópie výsledku. future.share() prenesie stav z std::future<T> do std::shared_future<T>; zdrojový objekt má potom valid() == false.

std::shared_future::get() čaká na pripravenosť a vracia const T&; pre std::shared_future<T&> vracia T& a pre std::shared_future<void> nevracia žiadnu hodnotu. Ak je uložená výnimka, vyhodí ju. Na rozdiel od std::future::get() stav nespotrebuje: opakované volania sú povolené. Odkaz na uloženú hodnotu sa nesmie použiť po zničení zdieľaného stavu; referenčná špecializácia nepredlžuje životnosť odkazovaného objektu.

std::shared_future::wait() čaká na pripravenosť bez získania výsledku alebo vyhodenia uloženej výnimky. std::shared_future::wait_for(duration) vracia std::future_status::ready, std::future_status::timeout alebo std::future_status::deferred. Pri odloženej úlohe vráti deferred bez jej spustenia; wait() alebo get() ju môže vykonať. Časový limit prácu nezruší a neposkytuje prísnu záruku času návratu.

Tieto tri operácie vyžadujú valid() == true; porušenie tejto podmienky spôsobuje nedefinované správanie, nie zaručenú výnimku. V rôznych vláknach používajte samostatné kópie handle. Pripravenosť synchronizuje sprístupnenie výsledku, ale neskoršie súbežné zmeny údajov si vyžadujú vlastnú synchronizáciu. Príklad zámerne používa jedno vlákno: ukazuje zdieľaný stav a opakované čítanie bez závislosti od plánovania.

Prí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ýsledok

timeout: true
ready: true
42 42 42

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje