c – 在其他std ::线程机制上使用std :: promise是个好主意？

我试图建立一些启发式来帮助我决定使用适当的std ::线程类.

据我所知,从最高级别(最简单易用,但最不灵活)到最低级别,我们有：

> 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来实现一些库机制),@R_291_9447@更容易地解释如何选择适当的类到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：

有助于澄清什么时候使用承诺.但是,我们必须记住,std :: mutex可能是必要的,因为承诺可能会根据用途从不同的线程访问.

另外David’s Rodriguez’s answer也很出色：

但是作为一种替代方案,为什么不只是简单地在结果的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';
}