Wie man std :: promise in einen Thread übergibt? von std :: move oder von std :: shared_ptr?

Question

#include <future> 

using namespace std; 

void t1(promise<int> p) 
{ 
    this_thread::sleep_for(chrono::seconds(5)); 
    p.set_value(0); 
} 

void t2(shared_ptr<promise<int>> p) 
{ 
    this_thread::sleep_for(chrono::seconds(5)); 
    p->set_value(0); 
} 

future<int> f1() 
{ 
    promise<int> p; 
    async(t1, move(p)); 

    return p.get_future(); 
} 

future<int> f2() 
{ 
    auto p = make_shared<promise<int>>(); 
    async(t2, p); 

    return p->get_future(); 
} 

int main() 
{ 
    f1().get(); 
    f2().get(); 

    return 0; 
} 

Meine Frage ist:

Wie ein std::promise Objekt in einen Thread passieren, von std::move oder durch std::shared_ptr?

Was ist besser?

Answer 1

Zuerst die Zukunft, dann verschieben Sie das Versprechen in den Thread.

std::future<int> f() { 
    std::promise<int> p; 
    auto r=p.get_future(); 
    std::async(t1, move(p)); 
    return r; 
} 

Natürlich ist dumm, weil die Nutzung von async blockiert, bis die Aufgabe abgeschlossen ist. Aber es ist die richtige Verwendung von promise.

Ein Versprechen zu teilen ist schlecht, es sollte einen einzigartigen Besitz haben, da nur einer seinen Wert festlegen sollte. Und wer das ist, sollte seine Lebenszeit besitzen.

Nach dem Umzug können Sie keine Zukunft mehr daraus machen.