packaged_task 和 async 有什么区别

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 和 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，或者如果情况发生变化您不关心结果：

{
    auto pizza = std::async(get_pizza);
    /* ... */
    if(need_to_go)
        return;          // ~future will block
    else
       eat(pizza.get());
}   

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

进一步的区别

通过使用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";

另外，在调用f.get() 之前需要调用packaged_task，否则你的程序将冻结，因为未来永远不会准备好：

std::packaged_task<int(int,int)> task(...);
auto f = task.get_future();
std::cout << f.get() << "\n"; // oops!
task(2,3);

TL;DR

如果您想完成某些事情并且不在乎何时完成，请使用std::async，如果您想结束事情以便将它们移动到其他线程或稍后调用它们，请使用std::packaged_task。或者，引用Christian：

最后，std::packaged_task 只是实现std::async 的较低级别功能（这就是为什么如果与其他较低级别的东西一起使用，它可以做的比std::async 更多，例如std::thread）。简单地说，std::packaged_task 是一个链接到 std::future 的 std::function 和 std::async 包装并调用 std::packaged_task（可能在不同的线程中）。

Answer 2

TL;DR

std::packaged_task 允许我们将std::future“绑定”到某个可调用对象，然后控制该可调用对象将在何时何地执行，而无需该未来对象。

std::async 启用第一个，但不启用第二个。也就是说，它允许我们获得一些可调用对象的未来，但是如果没有这个未来对象，我们就无法控制它的执行。

实际例子

下面是一个实际的问题示例，该问题可以使用std::packaged_task 解决，但不能使用std::async。

考虑你想实现一个线程池。它由固定数量的工作线程和一个共享队列组成。但是共享队列是什么？ std::packaged_task 很适合这里。

template <typename T>
class ThreadPool {
public:
  using task_type = std::packaged_task<T()>;

  std::future<T> enqueue(task_type task) {
      // could be passed by reference as well...
      // ...or implemented with perfect forwarding
    std::future<T> res = task.get_future();
    { std::lock_guard<std::mutex> lock(mutex_);
      tasks_.push(std::move(task));
    }
    cv_.notify_one();
    return res;
  }

  void worker() { 
    while (true) {  // supposed to be run forever for simplicity
      task_type task;
      { std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this]{ return !this->tasks_.empty(); });
        task = std::move(tasks_.top());
        tasks_.pop();
      }
      task();
    }
  }
  ... // constructors, destructor,...
private:
  std::vector<std::thread> workers_;
  std::queue<task_type> tasks_;
  std::mutex mutex_;
  std::condition_variable cv_;
};

std::async 无法实现此类功能。我们需要从enqueue() 返回一个std::future。如果我们在那里调用std::async（即使使用deferred 策略）并返回std::future，那么我们将无法选择如何在worker() 中执行调用。请注意，您不能为同一个共享状态创建多个期货（期货不可复制）。

Answer 3

打包任务与异步

p> 打包的任务包含一个任务[function or function object] 和未来/承诺对。当任务执行 return 语句时，它会在 packaged_task 的 promise 上引发 set_value(..)。

a> 给定 Future、promise 和打包任务，我们可以创建简单的任务而无需过多担心线程[线程只是我们为运行任务而提供的东西]。

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

Answer 4

"类模板 std::packaged_task 包装了任何可调用的目标 （函数、lambda 表达式、绑定表达式或其他函数 object) 以便可以异步调用它。它的返回值或 抛出的异常存储在可以访问的共享状态中 通过 std::future 对象。”

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