Namespaces
Variants

std:: shared_future

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
shared_future
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::shared_future
Défini dans l'en-tête <future>
template < class T > class shared_future ;
(1) (depuis C++11)
template < class T > class shared_future < T & > ;
(2) (depuis C++11)
template <> class shared_future < void > ;
(3) (depuis C++11)

Le modèle de classe std::shared_future fournit un mécanisme pour accéder au résultat d'opérations asynchrones, similaire à std::future , sauf que plusieurs threads sont autorisés à attendre le même état partagé. Contrairement à std::future , qui est seulement déplaçable (donc une seule instance peut se référer à un résultat asynchrone particulier), std::shared_future est copiable et plusieurs objets shared future peuvent se référer au même état partagé.

L'accès au même état partagé depuis plusieurs threads est sûr si chaque thread y accède via sa propre copie d'un objet shared_future .

Table des matières

Fonctions membres

construit l'objet future
(fonction membre publique)
détruit l'objet future
(fonction membre publique)
assigne le contenu
(fonction membre publique)
Obtention du résultat
retourne le résultat
(fonction membre publique)
État
vérifie si le future a un état partagé
(fonction membre publique)
attend que le résultat devienne disponible
(fonction membre publique)
attend le résultat, retourne s'il n'est pas disponible après la durée de timeout spécifiée
(fonction membre publique)
attend le résultat, retourne s'il n'est pas disponible jusqu'à ce que le point temporel spécifié soit atteint
(fonction membre publique)

Exemple

Un shared_future peut être utilisé pour signaler plusieurs threads simultanément, similairement à std::condition_variable::notify_all() .

Exécuter ce code 
#include <chrono>
#include <future>
#include <iostream>
int main()
{   
    std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;
    std::shared_future<void> ready_future(ready_promise.get_future());
    std::chrono::time_point<std::chrono::high_resolution_clock> start;
    auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli> 
    {
        t1_ready_promise.set_value();
        ready_future.wait(); // waits for the signal from main()
        return std::chrono::high_resolution_clock::now() - start;
    };
    auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli> 
    {
        t2_ready_promise.set_value();
        ready_future.wait(); // waits for the signal from main()
        return std::chrono::high_resolution_clock::now() - start;
    };
    auto fut1 = t1_ready_promise.get_future();
    auto fut2 = t2_ready_promise.get_future();
    auto result1 = std::async(std::launch::async, fun1);
    auto result2 = std::async(std::launch::async, fun2);
    // wait for the threads to become ready
    fut1.wait();
    fut2.wait();
    // the threads are ready, start the clock
    start = std::chrono::high_resolution_clock::now();
    // signal the threads to go
    ready_promise.set_value();
    std::cout << "Thread 1 received the signal "
              << result1.get().count() << " ms after start\n"
              << "Thread 2 received the signal "
              << result2.get().count() << " ms after start\n";
}

Sortie possible : 

Thread 1 received the signal 0.072 ms after start
Thread 2 received the signal 0.041 ms after start

Voir aussi

(C++11)
exécute une fonction de manière asynchrone (potentiellement dans un nouveau thread) et retourne une std::future qui contiendra le résultat
(modèle de fonction)
(C++11)
attend une valeur qui est définie de manière asynchrone
(modèle de classe)