据我所知,从最高级别(最简单易用,但最不灵活)到最低级别,我们有：
> std :: async with / std :: future(std :: shared_future)(当你想在一次性抛出的生产者线程异步时执行)
> std :: packed_task(当你想要分配一个生产者,但是延迟对线程的调用)
> std :: promise(???)
我认为我有一个正确的把握,什么时候使用前两个,但我仍然不清楚std :: promise.
std :: future与std :: async调用相结合,有效地将生成的回调/函子/ lambda转换为异步调用(根据定义立即返回).一个单一的消费者可以调用std :: future :: get()来阻止调用,以获得结果.
std :: shared_future只是一个允许多个消费者的版本.
如果要将std :: future值与生产者回调绑定,但是希望将实际调用延迟到稍后的时间(将任务与生成线程相关联),则std :: packaging_task是正确的选择.但是现在,由于std :: package_task的相应std ::未来可能会在一般情况下被多线程访问,所以我们可能需要注意使用std :: mutex.请注意,使用std :: async,在第一种情况下,我们不必担心锁定.
读了some interesting links on promise后,我觉得我理解了它的机制和如何设置它,但是我的问题是,你什么时候可以选择使用其他三个承诺？
我正在寻找更多的应用程序级答案,如经验法则(填写上面的3.),而不是链接中的答案(例如使用std :: promise来实现一些库机制),所以我可以更容易地解释如何选择适当的类到std :: thread的开始用户.
换句话说,有一个很有用的例子,我可以用一个std :: promise做的,不能用其他机制做的.
回答
一个std ::未来是一个奇怪的野兽：一般来说,你不能直接修改它的值.
可以修改其价值的三个生产者有：
> std :: async通过异步回调,这将返回一个std :: future实例.
> std :: packed_task,当传递给线程时,它将调用其回调,从而更新与该std :: packaging_task关联的std :: future实例.这种机制允许生产者的早期绑定,但是稍后的调用.
> std :: promise,它允许通过其set_value()调用修改其关联的std :: future.通过直接控制std :: future的突变,我们必须确保设计是线程安全的,如果有多个生产者(使用std :: mutex是必需的).
我想SethCarnegie’s answer：
An easy way to think of it is that you can either set a future by
returning a value or by using a promise. future has no set method;
that functionality is provided by promise.
有助于澄清什么时候使用承诺.但是,我们必须记住,std :: mutex可能是必要的,因为承诺可能会根据用途从不同的线程访问.
另外David’s Rodriguez’s answer也很出色：
The consumer end of the communication channel would use a std::future
to consume the datum from the shared state,while the producer thread
would use a std::promise to write to the shared state.
但是作为一种替代方案,为什么不只是简单地在结果的stl容器上使用std :: mutex,并且生成器的一个线程或线程池对容器执行操作？使用std :: promise,而不是买我,除了一些额外的可读性vs一个stl容器的结果？
在std :: promise版本中,控件似乎更好：
> wait()将在给定的未来阻塞,直到产生结果
>如果只有一个生产者线程,则不需要互斥体
以下google-test通过helgrind和drd,确认使用单个生产者,并使用wait(),不需要互斥体.
测试
static unsigned MapFunc( std::string const& str )
{
if ( str=="one" ) return 1u;
if ( str=="two" ) return 2u;
return 0u;
}
TEST( Test_future,Try_promise )
{
typedef std::map<std::string,std::promise<unsigned>> MAP;
MAP my_map;
std::future<unsigned> f1 = my_map["one"].get_future();
std::future<unsigned> f2 = my_map["two"].get_future();
std::thread{
[ ]( MAP& m )
{
m["one"].set_value( MapFunc( "one" ));
m["two"].set_value( MapFunc( "two" ));
},std::ref( my_map )
}.detach();
f1.wait();
f2.wait();
EXPECT_EQ( 1u,f1.get() );
EXPECT_EQ( 2u,f2.get() );
}
解决方法
#include <iostream>
#include <future>
#include <thread>
int main()
{
// future from a packaged_task
std::packaged_task<int()> task([](){ return 7; }); // wrap the function
std::future<int> f1 = task.get_future(); // get a future
std::thread(std::move(task)).detach(); // launch on a thread
// future from an async()
std::future<int> f2 = std::async(std::launch::async,[](){ return 8; });
// future from a promise
std::promise<int> p;
std::future<int> f3 = p.get_future();
std::thread( [](std::promise<int>& p){ p.set_value(9); },std::ref(p) ).detach();
std::cout << "Waiting...";
f1.wait();
f2.wait();
f3.wait();
std::cout << "Done!\nResults are: "
<< f1.get() << ' ' << f2.get() << ' ' << f3.get() << '\n';
}
版画
Waiting…Done!
Results are: 7 8 9
期货与所有三个线程一起使用以获得其结果,并且第三个线程使用承诺,以通过除返回值之外的方式来实现未来.此外,单线程可以通过承诺实现具有不同价值的多个期货,否则它将无法实现.
想到这一点的简单方法是,您可以通过返回值或使用承诺来设置未来.未来没有设定方法;该功能由承诺提供.您可以根据情况允许,选择您需要的.