CKTIS / C++
std::shared_future — gemeinsamer Zugriff auf ein Ergebnis
std::shared_future ermöglicht mehreren Empfängern den Zugriff auf dasselbe Ergebnis oder denselben Fehler. Er ist kopierbar und erlaubt wiederholte Aufrufe von get(); wait() wartet auf die Bereitschaft, während wait_for() sie mit einer Zeitbegrenzung prüft.
Version: 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> aus <future> ist ein kopierbarer Handle auf einen gemeinsamen Zustand, der ein Ergebnis oder einen Fehler enthält. Kopien verweisen auf denselben Zustand, nicht auf Kopien des Ergebnisses. future.share() überträgt den Zustand von std::future<T> auf std::shared_future<T>; das Quellobjekt hat danach valid() == false.
std::shared_future::get() wartet auf die Bereitschaft und gibt const T& zurück; bei std::shared_future<T&> gibt es T& zurück, bei std::shared_future<void> keinen Wert. Ein gespeicherter Fehler wird gegebenenfalls ausgelöst. Anders als std::future::get() verbraucht der Aufruf den Zustand nicht: Wiederholte Aufrufe sind erlaubt. Eine Referenz auf den gespeicherten Wert darf nach der Zerstörung des gemeinsamen Zustands nicht mehr verwendet werden; die Referenzspezialisierung verlängert die Lebensdauer des referenzierten Objekts nicht.
std::shared_future::wait() wartet auf die Bereitschaft, ohne das Ergebnis abzurufen oder den gespeicherten Fehler auszulösen. std::shared_future::wait_for(duration) gibt std::future_status::ready, std::future_status::timeout oder std::future_status::deferred zurück. Bei einer aufgeschobenen Aufgabe gibt es deferred zurück, ohne sie zu starten; wait() oder get() kann sie ausführen. Ein Timeout bricht die Arbeit weder ab noch garantiert es eine strikte Rückkehrzeit.
Vor diesen drei Operationen muss valid() == true gelten; ein Verstoß führt zu undefiniertem Verhalten, nicht zu einer garantierten Ausnahme. Verwende in verschiedenen Threads separate Handle-Kopien. Die Bereitschaft synchronisiert die Veröffentlichung des Ergebnisses, aber spätere gleichzeitige Änderungen an Daten benötigen eine eigene Synchronisierung. Das Beispiel verwendet absichtlich nur einen Thread: Es zeigt den gemeinsamen Zustand und wiederholte Lesezugriffe ohne Abhängigkeit von der Ablaufplanung.
Beispiele
#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';
}
Ergebnis
timeout: true ready: true 42 42 42
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.