C++ `std::packaged_task`：将可调用对象封装为异步任务

好的，系好安全带，各位技术大佬们！今天我们要聊的是C++的std::packaged_task，这玩意儿听起来像个高科技快递包装，但实际上，它是C++并发编程中一个非常实用的工具，能把你的函数或者可调用对象打包成一个异步任务，方便你扔给线程去执行，然后等你心情好的时候再去取结果。

什么是std::packaged_task？

简单来说，std::packaged_task是一个模板类，它的作用是将一个可调用对象（函数、函数对象、lambda表达式等）和一个std::future关联起来。你可以把packaged_task想象成一个快递打包员，它负责把你的函数打包好，贴上地址（也就是std::future），然后交给快递员（线程）去送货。等你想要取货的时候，就可以通过std::future拿到结果。

std::packaged_task的优点

异步执行： 这是最核心的优势。它可以让你把耗时的任务放到后台线程执行，避免阻塞主线程，提高程序的响应速度。
结果获取： 通过与std::future的关联，可以方便地获取异步任务的执行结果。
异常处理： 如果异步任务执行过程中抛出异常，std::future会持有这个异常，等你取结果的时候再抛出来，保证了异常的传递。
通用性： 可以封装各种可调用对象，包括普通函数、函数对象、lambda表达式等。

std::packaged_task的使用方法

std::packaged_task的使用通常包含以下几个步骤：

创建std::packaged_task对象： 指定函数签名和可调用对象。
获取std::future对象： 通过get_future()方法获取与packaged_task关联的std::future。
启动异步任务： 将packaged_task交给线程执行，或者直接调用()运算符执行。
获取结果： 通过std::future的get()方法获取异步任务的执行结果。

代码示例：基础篇

咱们先来个简单的例子，演示一下std::packaged_task的基本用法：

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

int add(int a, int b) {
  std::cout << "Executing add in thread: " << std::this_thread::get_id() << std::endl;
  return a + b;
}

int main() {
  // 1. 创建 packaged_task 对象，指定函数签名和可调用对象
  std::packaged_task<int(int, int)> task(add);

  // 2. 获取 future 对象
  std::future<int> future = task.get_future();

  // 3. 启动异步任务 (方法一：交给线程执行)
  std::thread t(std::move(task), 5, 3); // 注意：packaged_task 只能移动一次

  // 3. 启动异步任务 (方法二：直接调用 () 运算符)
  // task(5, 3); // 如果使用这种方式，就不能再交给线程了，否则会崩溃

  // 4. 获取结果
  std::cout << "Waiting for result..." << std::endl;
  int result = future.get(); // get() 会阻塞，直到结果可用
  std::cout << "Result: " << result << std::endl;

  t.join();

  return 0;
}

在这个例子中，我们首先创建了一个std::packaged_task对象task，它封装了add函数，并指定了add函数的参数类型和返回值类型。然后，我们通过task.get_future()获取了一个std::future对象future，它代表了异步任务的结果。接着，我们创建了一个线程t，并将task移动到线程中执行。注意，packaged_task 只能移动一次，因为它内部持有可调用对象的所有权。最后，我们通过future.get()获取了异步任务的执行结果。future.get()会阻塞，直到结果可用。

代码示例：Lambda表达式篇

std::packaged_task也可以封装lambda表达式，这在很多情况下非常方便：

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

int main() {
  // 创建 packaged_task 对象，封装 lambda 表达式
  std::packaged_task<int(int)> task([](int x) {
    std::cout << "Executing lambda in thread: " << std::this_thread::get_id() << std::endl;
    return x * x;
  });

  // 获取 future 对象
  std::future<int> future = task.get_future();

  // 启动异步任务
  std::thread t(std::move(task), 7);

  // 获取结果
  std::cout << "Waiting for result..." << std::endl;
  int result = future.get();
  std::cout << "Result: " << result << std::endl;

  t.join();

  return 0;
}

这个例子中，我们使用lambda表达式定义了一个计算平方的函数，然后将其封装到std::packaged_task中。

代码示例：异常处理篇

std::packaged_task还有一个重要的功能，就是异常处理。如果异步任务执行过程中抛出了异常，std::future会持有这个异常，等你调用get()方法时再抛出来。

#include <iostream>
#include <future>
#include <thread>
#include <stdexcept>

int divide(int a, int b) {
  if (b == 0) {
    throw std::runtime_error("Division by zero!");
  }
  return a / b;
}

int main() {
  // 创建 packaged_task 对象
  std::packaged_task<int(int, int)> task(divide);

  // 获取 future 对象
  std::future<int> future = task.get_future();

  // 启动异步任务
  std::thread t(std::move(task), 10, 0);

  // 获取结果 (并处理异常)
  try {
    std::cout << "Waiting for result..." << std::endl;
    int result = future.get();
    std::cout << "Result: " << result << std::endl;
  } catch (const std::exception& e) {
    std::cerr << "Exception caught: " << e.what() << std::endl;
  }

  t.join();

  return 0;
}

在这个例子中，divide函数可能会抛出std::runtime_error异常。当b为0时，divide函数会抛出异常，std::future会持有这个异常，当我们在main函数中调用future.get()时，这个异常会被重新抛出，我们可以通过try-catch块来捕获并处理这个异常。

进阶技巧：std::bind的妙用

有时候，我们可能需要预先绑定一些参数给可调用对象，这时候std::bind就派上用场了。

#include <iostream>
#include <future>
#include <thread>
#include <functional>

int multiply(int a, int b, int c) {
  return a * b * c;
}

int main() {
  // 使用 std::bind 预先绑定参数
  auto bound_multiply = std::bind(multiply, 2, std::placeholders::_1, 3);

  // 创建 packaged_task 对象，封装绑定后的函数对象
  std::packaged_task<int(int)> task(bound_multiply);

  // 获取 future 对象
  std::future<int> future = task.get_future();

  // 启动异步任务
  std::thread t(std::move(task), 5);

  // 获取结果
  std::cout << "Waiting for result..." << std::endl;
  int result = future.get();
  std::cout << "Result: " << result << std::endl;

  t.join();

  return 0;
}

在这个例子中，我们使用std::bind预先绑定了multiply函数的两个参数2和3，只留下一个参数std::placeholders::_1等待传递。然后，我们将绑定后的函数对象bound_multiply封装到std::packaged_task中。

std::packaged_task与其他并发工具的比较

工具	描述	优点	缺点	适用场景
`std::thread`	创建和管理线程。	简单直接，可以完全控制线程的生命周期和行为。	需要手动管理线程的生命周期，容易出错，无法直接获取线程的返回值，异常处理也比较麻烦。	需要精细控制线程行为，不需要返回值，或者使用其他方式获取返回值的场景。
`std::async`	启动一个异步任务，由系统自动选择在新的线程或当前线程中执行。	使用简单，无需手动创建线程，系统自动管理线程的生命周期，可以通过`std::future`获取返回值和处理异常。	无法控制任务的执行方式（是否创建新线程），可能存在资源竞争。	只需要简单地启动一个异步任务，不需要精细控制线程行为的场景。
`std::packaged_task`	将可调用对象封装为异步任务，并与`std::future`关联。	可以灵活地控制异步任务的执行方式（通过线程或直接调用），可以通过`std::future`获取返回值和处理异常，可以预先绑定参数。	需要手动创建线程，但是可以更好地控制线程的行为。	需要灵活控制异步任务的执行方式，需要获取返回值和处理异常，或者需要预先绑定参数的场景。
线程池	维护一个线程集合，用于执行异步任务。	可以重复利用线程，减少线程创建和销毁的开销，提高程序的性能。	实现比较复杂，需要考虑线程同步和任务调度等问题。	需要频繁执行异步任务，且任务量比较大的场景。

注意事项

所有权转移： std::packaged_task对象只能移动（move），不能拷贝（copy）。这意味着你只能将它传递给一个线程，不能同时传递给多个线程。
std::future::get()的阻塞性： std::future::get()方法会阻塞当前线程，直到异步任务完成并返回结果。如果你不想阻塞，可以使用std::future::wait_for()或std::future::wait_until()方法来等待一段时间，或者使用std::future::is_ready()方法来检查结果是否可用。
异常安全： 确保你的可调用对象是异常安全的。如果可调用对象抛出异常，std::future会持有这个异常，并在你调用get()方法时重新抛出。因此，你需要确保你的代码能够正确处理这些异常。

总结

std::packaged_task是一个强大的工具，它可以让你方便地创建和管理异步任务，并获取任务的执行结果和处理异常。掌握std::packaged_task的使用方法，可以提高你的C++并发编程能力，编写出更高效、更健壮的程序。希望今天的讲解能够帮助你更好地理解和使用std::packaged_task。记住，实践是检验真理的唯一标准，多写代码，多尝试，你才能真正掌握它。

好了，今天的分享就到这里，希望大家有所收获！下次再见！

发表回复 取消回复

发表回复取消回复