异步任务

前面几节我们学习了线程、互斥和原子操作——这些是并发编程的底层构建块。本节将上升到任务级并行的抽象层次:你只需声明"我要异步执行这个计算",标准库替你管理线程的创建和结果的传递。

任务 vs 线程

线程是操作系统的执行单元,任务是逻辑上的工作单元。std::async 让你面向任务编程——不必关心底层使用了几个线程、谁来调度。这是现代 C++ 推荐的并发编程入口。

std::async 与启动策略

std::async 是最简单的异步执行方式。它接收一个可调用对象和参数,返回一个 std::future 用于获取结果。

#include <future>
#include <iostream>
#include <chrono>
#include <cmath>

// 模拟耗时计算
double heavy_computation(double x) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return std::sqrt(x * x + 1.0);
}

int main() {
    // 启动异步任务 — 可能在新线程中执行
    auto future = std::async(std::launch::async, heavy_computation, 42.0);

    // 主线程继续做其他工作...
    std::cout << "主线程继续工作,不被阻塞\n";

    // 需要结果时调用 get()(阻塞直到计算完成)
    double result = future.get();
    std::cout << "计算结果: " << result << "\n";
}

启动策略(Launch Policy)

std::launch 枚举控制任务何时、如何执行:

// 策略1: launch::async — 保证在新线程中立即启动
auto f1 = std::async(std::launch::async, [] {
    return expensive_work();
});

// 策略2: launch::deferred — 延迟到 get()/wait() 时才在调用线程执行
auto f2 = std::async(std::launch::deferred, [] {
    return expensive_work();  // 直到 f2.get() 才运行
});

// 策略3: async | deferred(默认)— 实现自行决定
auto f3 = std::async(std::launch::async | std::launch::deferred, [] {
    return expensive_work();
});

deferred 的陷阱

如果使用默认策略且实现选择了 deferred,wait_for 永远返回 deferred 状态而不会超时。使用超时逻辑时务必显式指定 launch::async。此外,deferred 任务在调用者线程执行,没有真正的并行。

std::future — 异步结果的消费端

std::future<T> 是一次性的结果容器。它代表一个"尚未可用但终将到来"的值。

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

int main() {
    auto future = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return 42;
    });

    // wait_for: 非阻塞地检查是否完成
    using namespace std::chrono_literals;
    while (true) {
        auto status = future.wait_for(500ms);
        if (status == std::future_status::ready) {
            break;
        } else if (status == std::future_status::timeout) {
            std::cout << "还在计算中...\n";
        }
        // future_status::deferred 表示延迟任务尚未启动
    }

    // get() 只能调用一次!调用后 future 变为无效状态
    int result = future.get();
    std::cout << "结果: " << result << "\n";

    // future.valid() == false,再次 get() 会抛 std::future_error
}

std::shared_future — 多消费者共享

auto future = std::async(std::launch::async, [] { return compute(); });
std::shared_future<int> shared = future.share();

// 多个线程可以同时调用 shared.get()
std::jthread t1([shared] { use(shared.get()); });
std::jthread t2([shared] { use(shared.get()); });
// shared_future 可复制,每个副本都能 get()

std::promise — 异步结果的生产端

std::async 内部帮你管理了 promise。但有时你需要手动控制:在一个线程中设置值,在另一个线程中通过 future 获取。

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

void producer(std::promise<std::string> prom) {
    try {
        // 模拟工作
        std::this_thread::sleep_for(std::chrono::seconds(1));
        prom.set_value("Hello from producer!");
    } catch (...) {
        // 将异常传播给消费者
        prom.set_exception(std::current_exception());
    }
}

int main() {
    std::promise<std::string> prom;
    std::future<std::string> fut = prom.get_future();

    std::jthread t(producer, std::move(prom));

    // 消费者阻塞等待
    try {
        std::string msg = fut.get();
        std::cout << msg << "\n";
    } catch (const std::exception& e) {
        std::cerr << "异常: " << e.what() << "\n";
    }
}

promise 的一次性语义

set_value 或 set_exception 只能调用一次。如果 promise 被销毁时既没有设置值也没有设置异常,消费端的 get() 会收到 std::future_error(broken_promise)。

std::packaged_task — 封装可调用对象

std::packaged_task 将任意可调用对象包装成一个"任务包",调用时自动把结果存入关联的 future。这是构建线程池的关键组件。

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

int main() {
    // 将 lambda 包装成 packaged_task
    std::packaged_task<int(int, int)> task([](int a, int b) {
        return a + b;
    });

    // 获取关联的 future
    std::future<int> result = task.get_future();

    // task 可以在任意线程中被调用
    std::jthread worker([&task] {
        task(10, 20);  // 执行任务,结果自动存入 future
    });

    std::cout << "10 + 20 = " << result.get() << "\n";
}

// 实际应用:简易任务队列
class TaskQueue {
    std::queue<std::packaged_task<void()>> tasks_;
    std::mutex mutex_;

public:
    template<typename F>
    std::future<std::invoke_result_t<F>> submit(F&& f) {
        using R = std::invoke_result_t<F>;
        std::packaged_task<R()> task(std::forward<F>(f));
        auto future = task.get_future();
        {
            std::lock_guard lock(mutex_);
            // 类型擦除:将 packaged_task<R()> 包在 packaged_task<void()> 中
            tasks_.push(std::packaged_task<void()>(std::move(task)));
        }
        return future;
    }

    void execute_one() {
        std::packaged_task<void()> task;
        {
            std::lock_guard lock(mutex_);
            if (tasks_.empty()) return;
            task = std::move(tasks_.front());
            tasks_.pop();
        }
        task();
    }
};

std::latch — 一次性倒计数同步(C++20)

std::latch 是一个线程协调原语:初始化一个计数值,每个参与者完成工作后递减计数,所有等待者在计数到零时被释放。

#include <latch>
#include <thread>
#include <iostream>
#include <vector>

int main() {
    constexpr int num_workers = 4;
    std::latch work_done(num_workers);   // 倒计数 = 4
    std::latch start_signal(1);          // 用作起跑信号

    std::vector<std::jthread> workers;
    for (int i = 0; i < num_workers; ++i) {
        workers.emplace_back([&, i] {
            // 等待起跑信号
            start_signal.wait();

            // 模拟工作
            std::cout << "Worker " << i << " 正在工作\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(100 * (i + 1)));

            // 完成后递减计数
            work_done.count_down();
        });
    }

    // 发出起跑信号
    std::cout << "所有 worker 启动!\n";
    start_signal.count_down();

    // 等待所有 worker 完成
    work_done.wait();
    std::cout << "所有任务完成!\n";
}

latch vs condition_variable

std::latch 比手写 condition_variable + counter 更简洁、更不易出错。但它是一次性的——计数到零后不能重置。如果你需要可重复使用的同步点,请看下面的 std::barrier。

std::barrier — 可重用同步屏障(C++20)

std::barrier 让一组线程在某个点上相互等待,全部到达后一起继续。与 latch 不同,barrier 可以反复使用。

#include <barrier>
#include <thread>
#include <iostream>
#include <vector>
#include <format>

int main() {
    constexpr int num_threads = 3;
    constexpr int num_iterations = 4;

    // 完成函数:每次所有线程到达屏障后执行
    auto on_completion = []() noexcept {
        std::cout << "--- 所有线程到达屏障,进入下一轮 ---\n";
    };

    std::barrier sync_point(num_threads, on_completion);

    std::vector<std::jthread> threads;
    for (int id = 0; id < num_threads; ++id) {
        threads.emplace_back([&, id] {
            for (int iter = 0; iter < num_iterations; ++iter) {
                // 阶段1:并行计算
                std::cout << std::format("线程{} 执行第{}轮计算\n", id, iter);
                std::this_thread::sleep_for(
                    std::chrono::milliseconds(50 * (id + 1)));

                // 等待所有线程完成本轮
                sync_point.arrive_and_wait();

                // 阶段2:所有线程可以安全读取其他线程的结果
            }
        });
    }
}

综合实战:任务级并行计算

下面的例子展示了如何用 std::async 实现并行 map-reduce 模式:将工作分片并行计算,最后汇总结果。

#include <future>
#include <vector>
#include <numeric>
#include <iostream>
#include <algorithm>
#include <cmath>

// 并行计算向量中每个元素的函数值之和
template<typename Func>
double parallel_sum(const std::vector<double>& data, Func f,
                    size_t num_tasks = 4) {
    size_t chunk_size = data.size() / num_tasks;
    std::vector<std::future<double>> futures;

    for (size_t i = 0; i < num_tasks; ++i) {
        auto begin = data.begin() + i * chunk_size;
        auto end = (i == num_tasks - 1) ? data.end()
                                         : begin + chunk_size;

        futures.push_back(std::async(std::launch::async,
            [begin, end, &f] {
                double sum = 0.0;
                for (auto it = begin; it != end; ++it) {
                    sum += f(*it);
                }
                return sum;
            }));
    }

    // 汇总所有分片结果
    double total = 0.0;
    for (auto& fut : futures) {
        total += fut.get();
    }
    return total;
}

int main() {
    std::vector<double> data(1'000'000);
    std::iota(data.begin(), data.end(), 1.0);

    double result = parallel_sum(data, [](double x) {
        return std::sin(x) * std::cos(x);
    });

    std::cout << "并行计算结果: " << result << "\n";
}

std::async 的 future 析构行为

std::async 返回的 future 在析构时会阻塞等待任务完成。如果你忽略返回值(如 std::async(launch::async, f); 不保存 future),该语句会变成同步调用!务必保存 future 对象。

本节小结

  • std::async 是最简单的异步执行入口,launch::async 保证并行,launch::deferred 延迟执行
  • std::future 是一次性异步结果容器,支持 get()、wait_for() 超时查询;shared_future 支持多消费者
  • std::promise 是手动版本的"结果生产者",与 future 配对使用,可传值也可传异常
  • std::packaged_task 将可调用对象与 future 绑定,是构建任务队列的基石
  • std::latch 提供一次性倒计数同步,std::barrier 提供可重复使用的同步屏障
  • 任务级并行让你面向"做什么"编程,而非"用哪个线程"——更安全、更易维护