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 stellt einen Mechanismus zum Zugriff auf das Ergebnis asynchroner Operationen bereit, ähnlich wie std::future, mit dem Unterschied, dass mehrere Threads auf denselben gemeinsamen Zustand warten dürfen. Im Gegensatz zu std::future, das nur verschiebbar ist (sodass nur eine Instanz auf ein bestimmtes asynchrones Ergebnis verweisen kann), ist std::shared_future kopierbar, und mehrere shared_future-Objekte können auf denselben gemeinsamen Zustand verweisen.
Der Zugriff auf denselben gemeinsamen Zustand von mehreren Threads ist sicher, wenn jeder Thread dies über seine eigene Kopie eines shared_future-Objekts tut.
Inhalt |
[bearbeiten] Member functions
| konstruiert das Future-Objekt (public member function) | |
| zerstört das Future-Objekt (öffentliche Memberfunktion) | |
| weist den Inhalt zu (öffentliche Memberfunktion) | |
Ergebnis abrufen | |
| gibt das Ergebnis zurück (public member function) | |
Zustand | |
| prüft, ob das Future einen gemeinsamen Zustand hat (public member function) | |
| wartet, bis das Ergebnis verfügbar ist (public member function) | |
| wartet auf das Ergebnis, gibt zurück, wenn es für die angegebene Zeitdauer nicht verfügbar ist (public member function) | |
| wartet auf das Ergebnis, gibt zurück, wenn es nicht verfügbar ist, bis der angegebene Zeitpunkt erreicht ist (public member function) | |
[bearbeiten] Example
Eine shared_future kann verwendet werden, um mehrere Threads gleichzeitig zu signalisieren, ähnlich wie bei std::condition_variable::notify_all().
#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
[bearbeiten] Siehe auch
| (C++11) |
führt eine Funktion asynchron aus (potenziell in einem neuen Thread) und gibt ein std::future zurück, das das Ergebnis enthalten wird (Funktionsvorlage) |
| (C++11) |
wartet auf einen Wert, der asynchron gesetzt wird (Klassenvorlage) |
