异步任务
前面几节我们学习了线程、互斥和原子操作——这些是并发编程的底层构建块。本节将上升到任务级并行的抽象层次:你只需声明"我要异步执行这个计算",标准库替你管理线程的创建和结果的传递。
任务 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提供可重复使用的同步屏障- 任务级并行让你面向"做什么"编程,而非"用哪个线程"——更安全、更易维护