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
Definiert im Header <future>
template < class T > class shared_future ;
(1) (seit C++11)
template < class T > class shared_future < T & > ;
(2) (seit C++11)
template <> class shared_future < void > ;
(3) (seit C++11)

Die Klassenvorlage std::shared_future bietet einen Mechanismus, um auf das Ergebnis asynchroner Operationen zuzugreifen, ähnlich wie std::future , mit der Ausnahme, dass mehrere Threads auf denselben gemeinsamen Zustand warten dürfen. Im Gegensatz zu std::future , das nur beweglich ist (so dass nur eine Instanz auf ein bestimmtes asynchrones Ergebnis verweisen kann), ist std::shared_future kopierbar und mehrere gemeinsame Future-Objekte können auf denselben gemeinsamen Zustand verweisen.

Der Zugriff auf denselben gemeinsamen Zustand von mehreren Threads aus ist sicher, wenn jeder Thread dies über seine eigene Kopie eines shared_future -Objekts durchführt.

Inhaltsverzeichnis

Memberfunktionen

Konstruiert das Future-Objekt
(öffentliche Elementfunktion)
Destruiert das Future-Objekt
(öffentliche Elementfunktion)
Weist die Inhalte zu
(öffentliche Elementfunktion)
Ergebnis abrufen
Gibt das Ergebnis zurück
(öffentliche Elementfunktion)
Status
Prüft, ob das Future einen gemeinsamen Zustand hat
(öffentliche Elementfunktion)
Wartet, bis das Ergebnis verfügbar ist
(öffentliche Elementfunktion)
Wartet auf das Ergebnis, kehrt zurück, wenn es für die angegebene Timeout-Dauer nicht verfügbar ist
(öffentliche Elementfunktion)
Wartet auf das Ergebnis, kehrt zurück, wenn es nicht verfügbar ist, bis der angegebene Zeitpunkt erreicht wurde
(öffentliche Elementfunktion)

Beispiel

Ein shared_future kann verwendet werden, um mehrere Threads gleichzeitig zu signalisieren, ähnlich wie std::condition_variable::notify_all() .

Diesen Code ausführen 
#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";
}

Mögliche Ausgabe: 

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

Siehe auch

(C++11)
führt eine Funktion asynchron aus (möglicherweise in einem neuen Thread) und gibt ein std::future zurück, das das Ergebnis halten wird
(Funktions-Template)
(C++11)
wartet auf einen Wert, der asynchron gesetzt wird
(Klassen-Template)