std::packaged_task<T>（函数模板）是具有调用函数的std::async（FT）吗？

Question

正在尝试与 packaged_task<T>

合作

std::async 创建一个异步执行的线程并处理我们可以访问的数据，使用 class 模板 std::future<T> 和 get() 方法。

关于 packaged_task<T> 与 std::async 的区别，我应该知道什么？

与 packaged_task<T> 相关的线程是在我们调用 task(x) 函数时创建的吗？

以代码为例：

#include <iostream>
#include <thread>
#include <future>
#include <chrono>

using namespace std::chrono;

int main()
{

    int x(0),xr(0);

    std::future<int> fdata = std::async(std::launch::async,[&](int data) mutable throw() ->
                                        int
                                        {data++;
                                        std::this_thread::sleep_for(seconds(2));
                                        return data;}
                                        ,x);

    std::packaged_task<int(int)> task([&](int data) mutable throw() ->
                                        int
                                        {data++;
                                        std::this_thread::sleep_for(seconds(2));
                                        return data;}
                                        );
    std::future<int> xrp = task.get_future();

    task(x);

    xr=fdata.get();

    std::cout<<xr<<std::endl;
    std::cout<<xrp.get()<<std::endl;

    return 0;
}

Answer 1

std::async(ploicy, callable, args...)

如果策略是 std::async::launch，则启动一个新线程（如果资源可用）。

政策未定，可能推出也可能不推出。

如果策略是 std::async::deferred，则不会启动。

而 std::packaged_task 包装您的可调用对象，以便可以使用像

这样的新线程异步调用它

auto t1 = std::thread(std::move(taskObj), args...);
....
t1.join();

但是如果您像示例中那样使用它，它不会启动新线程。它本身不会启动新线程，但可以用来执行此操作。

std::packaged_task<T>（函数模板）是具有调用函数的std::async（FT）吗？

Is std::packaged_task<T> (Function Template) an std::async (FT) with an invoked function?

c++

multithreading

asynchronous

packaged-task

difference