Was ist std::promise?

Question

Ich bin ziemlich vertraut mit C++11's std::thread , std::async et std::future Komponenten (siehe z.B. diese Antwort ), die einfach zu handhaben sind.

Ich kann jedoch nicht ganz nachvollziehen, was std::promise ist, was es bewirkt und in welchen Situationen es am besten eingesetzt werden kann. Das Standarddokument selbst enthält außer der Klassenzusammenfassung nicht viele Informationen, und auch die std::thread .

Könnte jemand bitte ein kurzes, prägnantes Beispiel für eine Situation nennen, in der ein std::promise benötigt wird und wo es die sinnvollste Lösung ist?

Answer 1

Bei der asynchronen Verarbeitung gibt es im Grunde 3 Hauptkomponenten. C++11 konzentriert sich derzeit auf 2 von ihnen.

Die wichtigsten Dinge, die Sie benötigen, um eine Logik asynchron auszuführen, sind:

1. En Aufgabe (Logik verpackt als ein Funktor-Objekt), das "irgendwo" LÄUFT.

2. En tatsächlicher Verarbeitungsknoten - ein Thread, ein Prozess usw., der solche Funktoren AUSFÜHRT, wenn sie ihm zur Verfügung gestellt werden. Schauen Sie sich das "Command"-Entwurfsmuster an, um eine gute Vorstellung davon zu bekommen, wie ein einfacher Worker-Thread-Pool dies tut.

3. En Ergebnis Griff : Jemand braucht dieses Ergebnis, und er braucht ein Objekt, das es für ihn GET. Aus OOP- und anderen Gründen sollte jegliches Warten oder Synchronisieren in den APIs dieses Handles erfolgen.

C++11 nennt die Dinge, von denen ich in (1) spreche std::promise und die in (3) std::future . std::thread ist das einzige, was öffentlich für (2) zur Verfügung gestellt wird. Das ist bedauerlich, denn echte Programme müssen Thread- und Speicherressourcen verwalten, und die meisten wollen, dass Aufgaben in Thread-Pools ausgeführt werden, anstatt für jede kleine Aufgabe einen Thread zu erstellen und zu zerstören (was fast immer unnötige Leistungseinbußen verursacht und leicht zu einer Ressourcenverknappung führen kann, die noch schlimmer ist).

Laut Herb Sutter und anderen Mitgliedern des C++11-Brain-Trusts gibt es vorläufige Pläne, eine std::executor die - ähnlich wie in Java - die Grundlage für Thread-Pools und logisch ähnliche Setups für (2) bilden werden. Vielleicht werden wir das in C++2014 sehen, aber ich tippe eher auf C++17 (und Gott steh uns bei, wenn sie den Standard für diese Dinge verpfuschen).

Answer 2

http://www.cplusplus.com/reference/future/promise/

Erklärung in einem Satz: furture::get() wartet ewig auf promse::set_value().

void print_int(std::future<int>& fut) {
    int x = fut.get(); // future would wait prom.set_value forever
    std::cout << "value: " << x << '\n';
}

int main()
{
    std::promise<int> prom;                      // create promise

    std::future<int> fut = prom.get_future();    // engagement with future

    std::thread th1(print_int, std::ref(fut));  // send future to new thread

    prom.set_value(10);                         // fulfill promise
                                                 // (synchronizes with getting the future)
    th1.join();
    return 0;
}

Answer 3

Das Versprechen ist das andere Ende des Drahtes.

Stellen Sie sich vor, Sie müssen den Wert einer future die von einem async . Sie möchten jedoch nicht, dass die Berechnung im selben Thread erfolgt, und Sie erzeugen nicht einmal einen Thread "jetzt" - vielleicht wurde Ihre Software so konzipiert, dass sie einen Thread aus einem Pool auswählt, so dass Sie nicht wissen, ob Sie einen Thread erstellen können. die wird am Ende eine Berechnung durchführen.

Was geben Sie nun an diesen (noch unbekannten) Faden/diese Klasse/diese Entität weiter? Man übergibt nicht die future da es sich um die Ergebnis . Sie wollen etwas verabschieden, das verbunden zum future und das steht für das andere Ende des Kabels so werden Sie einfach die future ohne zu wissen, wer tatsächlich etwas berechnen/schreiben wird.

Dies ist die promise . Es ist eine Griff verbunden mit Ihrem future . Wenn die future ist eine Sprecher und mit get() Sie beginnen zu lauschen, bis ein Ton herauskommt, der promise ist eine Mikrofon aber nicht irgendein Mikrofon, es ist die Mikrofon, das über ein einziges Kabel mit dem Lautsprecher verbunden ist, den Sie in der Hand halten. Sie wissen vielleicht, wer am anderen Ende sitzt, aber Sie müssen es nicht wissen - Sie sagen es einfach und warten, bis die andere Partei etwas sagt.