CKTIS / C++
std::shared_future — gedeelde toegang tot een resultaat
Met std::shared_future kunnen meerdere gebruikers toegang krijgen tot hetzelfde resultaat of dezelfde uitzondering. Het is kopieerbaar en ondersteunt herhaalde aanroepen van get(); wait() wacht tot het klaar is, terwijl wait_for() dit met een tijdslimiet controleert.
Versie: 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> uit <future> is een kopieerbare handle naar een gedeelde status met een resultaat of uitzondering. Kopieën verwijzen naar dezelfde status, niet naar kopieën van het resultaat. future.share() draagt de status over van std::future<T> naar std::shared_future<T>; het bronobject heeft daarna valid() == false.
std::shared_future::get() wacht tot het resultaat klaar is en retourneert const T&; voor std::shared_future<T&> retourneert het T&, en voor std::shared_future<void> retourneert het geen waarde. Een opgeslagen uitzondering wordt, indien aanwezig, opnieuw opgegooid. Anders dan std::future::get() verbruikt deze aanroep de status niet: herhaalde aanroepen zijn toegestaan. Gebruik een verwijzing naar de opgeslagen waarde niet nadat de gedeelde status is vernietigd; de referentiespecialisatie verlengt de levensduur van het verwezen object niet.
std::shared_future::wait() wacht tot het resultaat klaar is zonder het op te halen of de opgeslagen uitzondering op te gooien. std::shared_future::wait_for(duration) retourneert std::future_status::ready, std::future_status::timeout of std::future_status::deferred. Voor een uitgestelde taak retourneert het deferred zonder de taak te starten; wait() of get() kan die uitvoeren. Een time-out annuleert het werk niet en biedt geen strikte garantie voor het terugkeermoment.
Voor deze drie bewerkingen is valid() == true vereist; schending hiervan leidt tot ongedefinieerd gedrag, niet tot een gegarandeerde uitzondering. Gebruik in verschillende threads aparte kopieën van de handle. De gereedheid synchroniseert het beschikbaar maken van het resultaat, maar latere gelijktijdige wijzigingen aan gegevens vereisen eigen synchronisatie. Het voorbeeld gebruikt bewust één thread: het toont de gedeelde status en herhaald lezen zonder afhankelijkheid van de planning.
Voorbeelden
#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';
}
Resultaat
timeout: true ready: true 42 42 42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.