std:: promise

Die Klassenvorlage std::promise bietet eine Einrichtung, um einen Wert oder eine Ausnahme zu speichern, die später asynchron über ein std::future -Objekt abgerufen wird, das durch das std::promise -Objekt erstellt wurde. Beachten Sie, dass das std::promise -Objekt nur einmal verwendet werden soll.

Jedes Promise ist assoziiert mit einem shared state , der einige Zustandsinformationen und ein result enthält, das möglicherweise noch nicht ausgewertet ist, zu einem Wert (möglicherweise void) ausgewertet wurde oder zu einer Exception ausgewertet wurde. Ein Promise kann drei Dinge mit dem Shared State tun:

• make ready : Das Promise speichert das Ergebnis oder die Ausnahme im gemeinsamen Zustand. Markiert den Zustand als bereit und entblockt alle Threads, die auf einen Future dieses gemeinsamen Zustands warten.
• release : Das Promise gibt seine Referenz auf den gemeinsamen Zustand auf. Falls dies die letzte solche Referenz war, wird der gemeinsame Zustand zerstört. Sofern es sich nicht um einen durch std:: async erstellten gemeinsamen Zustand handelt, der noch nicht bereit ist, blockiert dieser Vorgang nicht.
• abandon : Das Promise speichert eine Ausnahme vom Typ std::future_error mit Fehlercode std::future_errc::broken_promise , macht den gemeinsamen Zustand ready und gibt ihn anschließend frei .

Das Promise ist das "Push"-Ende des Promise-Future-Kommunikationskanals: Der Vorgang, der einen Wert im gemeinsamen Zustand speichert, synchronisiert-sich-mit (wie definiert in std::memory_order ) der erfolgreichen Rückkehr von jeder Funktion, die auf den gemeinsamen Zustand wartet (wie std::future::get ). Gleichzeitiger Zugriff auf denselben gemeinsamen Zustand kann sonst konfligieren: Beispielsweise müssen alle Aufrufer von std::shared_future::get entweder ausschließlich lesend zugreifen oder externe Synchronisation bereitstellen.

Memberfunktionen

Nicht-Member-Funktionen

Hilfsklassen

Beispiel

#include <chrono>
#include <future>
#include <iostream>
#include <numeric>
#include <thread>
#include <vector>
void accumulate(std::vector<int>::iterator first,
                std::vector<int>::iterator last,
                std::promise<int> accumulate_promise)
{
    int sum = std::accumulate(first, last, 0);
    accumulate_promise.set_value(sum); // Notify future
}
void do_work(std::promise<void> barrier)
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    barrier.set_value();
}
int main()
{
    // Demonstrate using promise<int> to transmit a result between threads.
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    std::promise<int> accumulate_promise;
    std::future<int> accumulate_future = accumulate_promise.get_future();
    std::thread work_thread(accumulate, numbers.begin(), numbers.end(),
                            std::move(accumulate_promise));
    // future::get() will wait until the future has a valid result and retrieves it.
    // Calling wait() before get() is not needed
    // accumulate_future.wait(); // wait for result
    std::cout << "result=" << accumulate_future.get() << '\n';
    work_thread.join(); // wait for thread completion
    // Demonstrate using promise<void> to signal state between threads.
    std::promise<void> barrier;
    std::future<void> barrier_future = barrier.get_future();
    std::thread new_work_thread(do_work, std::move(barrier));
    barrier_future.wait();
    new_work_thread.join();
}

result=21