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

Question

尝试与packaged_task<T>合作

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

我应该知道packaged_task<T> 的工作原理与std::async 的区别？

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

以代码为例：

#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();

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