Question

在使用C ++ 11的线程模型时，我注意到了

std::packaged_task<int(int,int)> task([](int a, int b) { return a + b; });
auto f = task.get_future();
task(2,3);
std::cout << f.get() << '\n';

和

auto f = std::async(std::launch::async, 
    [](int a, int b) { return a + b; }, 2, 3);
std::cout << f.get() << '\n';

似乎完全一样。我了解如果我使用std::async运行std::launch::deferred可能会有重大差异，但在这种情况下是否有一个？

这两种方法有什么区别，更重要的是，我应该使用哪种用例？

Answer 1

实际上，您刚才提供的示例显示了使用相当长的函数时的差异，例如

//! sleeps for one second and returns 1
auto sleep = [](){
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 1;
};

打包任务

packaged_task不会自己启动，你必须调用它：

std::packaged_task<int()> task(sleep);

auto f = task.get_future();
task(); // invoke the function

// You have to wait until task returns. Since task calls sleep
// you will have to wait at least 1 second.
std::cout << "You can see this after 1 second\n";

// However, f.get() will be available, since task has already finished.
std::cout << f.get() << std::endl;

`std::async`

另一方面，带有std::async的{{1}}将尝试在另一个线程中运行该任务：

launch::async

缺点

但在尝试将auto f = std::async(std::launch::async, sleep); std::cout << "You can see this immediately!\n"; // However, the value of the future will be available after sleep has finished // so f.get() can block up to 1 second. std::cout << f.get() << "This will be shown after a second!\n";用于所有内容之前，请记住，返回的未来有一个特殊的共享状态，这要求async阻止：

future::~future

因此，如果您想要真正的异步，则需要保留返回的std::async(do_work1); // ~future blocks std::async(do_work2); // ~future blocks /* output: (assuming that do_work* log their progress) do_work1() started; do_work1() stopped; do_work2() started; do_work2() stopped; */，或者如果情况发生变化则您不关心结果：

future

有关这方面的更多信息，请参阅Herb Sutter的文章async and ~future，其中描述了问题，以及Scott Meyer的std::futures from std::async aren't special，其中描述了这些见解。另请注意此行为was specified in C++14 and up，但也通常在C ++ 11中实现。

进一步的差异

通过使用{ auto pizza = std::async(get_pizza); /* ... */ if(need_to_go) return; // ~future will block else eat(pizza.get()); }，您无法再在特定线程上运行任务，其中std::async可以移动到其他线程。

std::packaged_task

此外，在调用std::packaged_task<int(int,int)> task(...); auto f = task.get_future(); std::thread myThread(std::move(task),2,3); std::cout << f.get() << "\n";之前需要调用packaged_task，否则您的程序将会冻结，因为未来永远不会准备就绪：

f.get()

TL; DR

使用std::packaged_task<int(int,int)> task(...); auto f = task.get_future(); std::cout << f.get() << "\n"; // oops! task(2,3);如果你想完成某些事情并且在完成时并不在意它们，并std::async如果你想要包装东西以便将它们移动到其他线程或调用他们以后。或者，引用Christian：

最后，std::packaged_task只是实现std::packaged_task的较低级别功能（如果与其他较低级别的内容一起使用，它可以比std::async更多，例如std::async {1}}）。简单地说std::thread是与std::packaged_task和std::function换行相关联的std::future并调用std::async（可能在不同的主题中）。

Answer 2

“类模板std :: packaged_task包装任何可调用目标   （函数，lambda表达式，绑定表达式或其他函数   对象），以便可以异步调用它。它的回报价值还是   抛出的异常存储在可以访问的共享状态中   通过std :: future对象。“

“模板函数async异步运行函数f   （可能在一个单独的线程中）并返回一个std :: future   最终保持该函数调用的结果。“

Answer 3

打包任务与异步

p＆gt; 打包任务包含任务[function or function object]和未来/保证对。当任务执行return语句时，它会导致set_value(..)的承诺packaged_task。

a＆gt; 鉴于Future，promise和package任务，我们可以创建简单的任务而不必过多担心线程[线程只是我们为运行任务而提供的东西]。

但是我们需要考虑要使用多少个线程，或者当前线程或另一个线程上的任务最佳运行等等。这样的描述可以由一个名为async()的线程启动程序处理，决定是否创建新线程或回收旧线程或只是在当前线程上运行任务。它会回归未来。

packaged_task和async有什么区别

3 个答案:

打包任务

`std::async`

缺点

进一步的差异

TL; DR

打包任务与异步