C++ `std::async`：异步执行函数的简便方法与陷阱

好的，各位观众，欢迎来到今天的“C++异步大作战”讲座！今天我们要聊的是std::async，一个让你轻松驾驭并发，仿佛拥有多个分身帮你干活的神奇工具。但是，别高兴太早，这玩意儿用不好，也会让你掉进各种坑里。所以，今天我们就来好好剖析一下std::async，看看它到底能干什么，又有哪些需要注意的地方。

第一幕：std::async初体验——你好，我的分身！

想象一下，你正在做一个复杂的图像处理程序。其中一个步骤需要进行大量的计算，耗时很久，让你的主线程卡得像老牛拉破车。这时候，std::async就派上用场了。它可以把这个计算任务扔给一个“分身”去做，而主线程可以继续响应用户操作，避免卡顿。

来，我们先看一个最简单的例子：

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

int calculate_sum(int a, int b) {
    std::cout << "Calculating sum in a separate thread...n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时计算
    return a + b;
}

int main() {
    std::cout << "Starting the main thread...n";

    // 使用 std::async 异步执行 calculate_sum
    std::future<int> result = std::async(std::launch::async, calculate_sum, 10, 20);

    std::cout << "Main thread continues to do other work...n";
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟主线程做其他事情

    // 获取异步计算的结果，这会阻塞，直到结果可用
    int sum = result.get();

    std::cout << "The sum is: " << sum << "n";
    std::cout << "Main thread finished.n";

    return 0;
}

在这个例子中，我们使用std::async启动了一个异步任务calculate_sum。std::launch::async告诉std::async，我们希望它在一个新的线程中执行这个函数。std::async返回一个std::future<int>对象，它代表了异步计算的结果。

主线程继续执行，模拟做一些其他的事情。最后，我们调用result.get()来获取异步计算的结果。get()方法会阻塞，直到结果可用。

第二幕：启动策略——你是要快还是慢？

std::async的启动策略非常重要，它决定了函数是在新线程中执行，还是在调用get()时执行。std::async接受一个可选的第一个参数，指定启动策略，它可以是：

• std::launch::async: 强制在一个新的线程中执行函数。
• std::launch::deferred: 延迟执行函数，直到调用get()或wait()。
• std::launch::any: 让系统自己决定使用哪个策略。

来，我们再看一个例子，这次使用std::launch::deferred：

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

int calculate_sum(int a, int b) {
    std::cout << "Calculating sum in the same thread...n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时计算
    return a + b;
}

int main() {
    std::cout << "Starting the main thread...n";

    // 使用 std::async 异步执行 calculate_sum，但是延迟执行
    std::future<int> result = std::async(std::launch::deferred, calculate_sum, 10, 20);

    std::cout << "Main thread continues to do other work...n";
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟主线程做其他事情

    // 获取异步计算的结果，这会阻塞，直到结果可用
    int sum = result.get();

    std::cout << "The sum is: " << sum << "n";
    std::cout << "Main thread finished.n";

    return 0;
}

在这个例子中，calculate_sum函数会在调用result.get()时才执行，并且是在主线程中执行的。

重要提示： 如果你不指定启动策略，std::async会使用std::launch::any。这意味着系统可能会选择在新线程中执行函数，也可能选择延迟执行。这取决于系统的资源状况和调度策略。所以，为了代码的可预测性，最好明确指定启动策略。

第三幕：std::future——异步结果的守护者

std::future是std::async返回的对象，它代表了异步计算的结果。它提供了一些方法来获取结果、检查状态等。

• get(): 获取异步计算的结果。如果结果还没有准备好，get()会阻塞，直到结果可用。只能调用一次，第二次调用会抛出异常。
• wait(): 等待异步计算完成。不返回任何值。
• wait_for(): 等待一段时间，如果异步计算在这段时间内没有完成，就返回std::future_status::timeout。
• valid(): 检查std::future对象是否有效，即是否关联到一个异步计算。

来，我们看一个使用wait_for()的例子：

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

int calculate_sum(int a, int b) {
    std::cout << "Calculating sum in a separate thread...n";
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 模拟耗时计算
    return a + b;
}

int main() {
    std::cout << "Starting the main thread...n";

    std::future<int> result = std::async(std::launch::async, calculate_sum, 10, 20);

    std::cout << "Main thread continues to do other work...n";

    // 等待 2 秒，看看结果是否准备好
    std::future_status status = result.wait_for(std::chrono::seconds(2));

    if (status == std::future_status::ready) {
        std::cout << "Result is ready!n";
        int sum = result.get();
        std::cout << "The sum is: " << sum << "n";
    } else if (status == std::future_status::timeout) {
        std::cout << "Timeout! Result is not ready yet.n";
    } else if (status == std::future_status::deferred) {
        std::cout << "Deferred! The task has not started yet.n";
    }

    std::cout << "Main thread finished.n";

    return 0;
}

在这个例子中，我们使用wait_for()等待2秒。如果calculate_sum在2秒内完成，我们就获取结果；否则，我们就输出一个超时信息。

第四幕：std::async的陷阱——一不小心就掉坑里！

std::async虽然好用，但是也有一些陷阱需要注意。

1. 忽略std::future对象： 这是一个非常常见的错误。如果你创建了一个std::async对象，但是没有保存返回的std::future对象，那么std::async会立即启动异步任务，并在任务完成后销毁。这可能会导致一些意想不到的问题，例如资源泄漏。

   // 错误的做法：忽略 std::future 对象
   std::async(std::launch::async, calculate_sum, 10, 20);
   // 异步任务会启动，并在完成后销毁 std::future 对象，可能会导致资源泄漏
   
   // 正确的做法：保存 std::future 对象
   std::future<int> result = std::async(std::launch::async, calculate_sum, 10, 20);

2. 多次调用get()： std::future::get()只能调用一次。如果多次调用get()，第二次调用会抛出std::future_error异常。

   std::future<int> result = std::async(std::launch::async, calculate_sum, 10, 20);
   int sum1 = result.get();
   // int sum2 = result.get(); // 错误：第二次调用 get() 会抛出异常

3. 异常处理： 如果异步任务抛出异常，那么在调用get()时，这个异常会被重新抛出。所以，你需要做好异常处理。

   #include <iostream>
   #include <future>
   #include <stdexcept>
   
   int calculate_sum(int a, int b) {
       std::cout << "Calculating sum in a separate thread...n";
       if (a < 0 || b < 0) {
           throw std::runtime_error("Invalid input: a and b must be non-negative.");
       }
       return a + b;
   }
   
   int main() {
       std::future<int> result = std::async(std::launch::async, calculate_sum, -10, 20);
   
       try {
           int sum = result.get();
           std::cout << "The sum is: " << sum << "n";
       } catch (const std::exception& e) {
           std::cerr << "Exception caught: " << e.what() << "n";
       }
   
       return 0;
   }

4. 死锁： 在多线程编程中，死锁是一个常见的问题。如果你的异步任务需要访问共享资源，并且没有正确地使用锁，那么可能会发生死锁。

5. 过度使用： 不要滥用std::async。创建线程是有开销的。如果你的任务非常简单，那么使用std::async可能会适得其反。

第五幕：进阶技巧——让std::async更上一层楼

1. 传递参数： std::async可以接受任意数量的参数，这些参数会被传递给异步执行的函数。你可以使用值传递、引用传递、移动语义等。

2. 返回复杂类型： std::async可以返回任意类型的结果，包括自定义类型。

3. 使用 Lambda 表达式： 你可以使用 Lambda 表达式来定义异步执行的函数。这可以让你更灵活地控制异步任务的行为。

   #include <iostream>
   #include <future>
   
   int main() {
       int x = 10;
       std::future<int> result = std::async(std::launch::async, [x]() {
           std::cout << "Calculating square in a separate thread...n";
           return x * x;
       });
   
       int square = result.get();
       std::cout << "The square is: " << square << "n";
   
       return 0;
   }

4. 结合 std::packaged_task： std::packaged_task 可以将一个可调用对象（函数、Lambda 表达式等）包装成一个异步任务，然后可以使用 std::future 获取任务的结果。它与 std::async 的一个区别在于，std::packaged_task 允许你在不同的线程中设置任务的参数和启动任务。

   #include <iostream>
   #include <future>
   #include <thread>
   
   int calculate_sum(int a, int b) {
       std::cout << "Calculating sum in a separate thread...n";
       return a + b;
   }
   
   int main() {
       // 创建一个 packaged_task，包装 calculate_sum 函数
       std::packaged_task<int(int, int)> task(calculate_sum);
   
       // 获取与 packaged_task 关联的 future
       std::future<int> result = task.get_future();
   
       // 在一个新的线程中启动任务
       std::thread t(std::move(task), 10, 20);
   
       // 获取异步计算的结果
       int sum = result.get();
   
       std::cout << "The sum is: " << sum << "n";
   
       t.join(); // 等待线程结束
   
       return 0;
   }

第六幕：std::async与线程池——更强大的并发控制

虽然std::async可以让你轻松地创建线程，但是它也有一些限制。例如，你无法控制线程的数量，也无法复用线程。

线程池是一种更强大的并发控制机制。它可以让你预先创建一组线程，然后将任务提交给线程池执行。这样可以避免频繁地创建和销毁线程，提高性能。

C++标准库并没有提供内置的线程池，但是你可以自己实现一个，或者使用第三方库。

总结：

std::async是一个非常方便的工具，可以让你轻松地进行异步编程。但是，你需要了解它的启动策略、std::future的用法，以及一些常见的陷阱。只有这样，你才能真正地掌握std::async，并将其应用到你的项目中。

特性	std::async	线程池
线程管理	自动创建和管理线程，但控制较少	手动创建和管理线程，提供更精细的控制
线程复用	每次调用 std::async 可能会创建一个新线程，线程不复用	线程池中的线程可以被多个任务复用，减少线程创建和销毁的开销
任务调度	任务调度由系统自动完成，无法精确控制	任务调度可以自定义，例如使用队列来管理任务
适用场景	简单的异步任务，不需要精细的线程控制	需要高性能和精细线程控制的场景，例如服务器应用、科学计算等
实现复杂度	简单易用	实现复杂度较高，需要考虑线程同步、任务调度等问题
资源开销	每次调用 std::async 可能会创建新线程，开销较高	线程池预先创建线程，可以减少线程创建和销毁的开销
异常处理	异步任务中的异常会在调用 future.get() 时重新抛出	需要手动处理线程池中任务的异常，例如记录日志、重试等

好了，今天的讲座就到这里。希望大家能够掌握std::async的用法，并在实际项目中灵活应用。记住，并发编程是一门艺术，需要不断地学习和实践。祝大家编程愉快！