Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::shared_future — accès partagé à un résultat

std::shared_future permet à plusieurs consommateurs d’accéder au même résultat ou à la même exception. Il est copiable et permet des appels répétés à get() ; wait() attend que le résultat soit prêt, tandis que wait_for() vérifie cet état avec un délai maximal.

Version : 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> de <future> est une poignée copiable vers un état partagé contenant un résultat ou une exception. Les copies désignent le même état, et non des copies du résultat. future.share() transfère l’état de std::future<T> vers std::shared_future<T> ; l’objet source a alors valid() == false.

std::shared_future::get() attend que le résultat soit prêt et renvoie const T& ; pour std::shared_future<T&>, il renvoie T&, et pour std::shared_future<void>, il ne renvoie aucune valeur. Il lève l’exception stockée, le cas échéant. Contrairement à std::future::get(), il ne consomme pas l’état : les appels répétés sont autorisés. Une référence à la valeur stockée ne doit pas être utilisée après la destruction de l’état partagé ; la spécialisation de référence ne prolonge pas la durée de vie de l’objet référencé.

std::shared_future::wait() attend que le résultat soit prêt sans le récupérer ni lever l’exception stockée. std::shared_future::wait_for(duration) renvoie std::future_status::ready, std::future_status::timeout ou std::future_status::deferred. Pour une tâche différée, il renvoie deferred sans la démarrer ; wait() ou get() peut l’exécuter. Un délai d’attente n’annule pas le travail et ne garantit pas un temps de retour strict.

Ces trois opérations exigent valid() == true ; le non-respect de cette condition entraîne un comportement indéfini, et non une exception garantie. Utilisez des copies distinctes de la poignée dans différents threads. L’état prêt synchronise la publication du résultat, mais les modifications concurrentes ultérieures des données nécessitent leur propre synchronisation. L’exemple utilise volontairement un seul thread : il montre l’état partagé et les lectures répétées sans dépendre de l’ordonnancement.

Exemples

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

Résultat

timeout: true
ready: true
42 42 42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources