std::async无法安全链式调用，因标准future无.then()、move后状态不确定、阻塞不可控、异常不传播；需用promise+thread或packaged_task手写任务链，或采用libunifex/boost.asio等带executor和continuation的方案。
为什么 std::async 串成链会崩掉内存或卡死
直接用 std::async 返回的 std::future 去调 .then() 是行不通的——C++17/20 标准库根本没提供 .then()。强行写 auto f1 = std::async(...); auto f2 = std::async([f1 = std::move(f1)]{ f1.get(); return do_next(); }); 看似链式，实则危险：f1 捕获进 lambda 后，若 f2 在 f1 完成前被调度，f1.get() 会阻塞当前线程；更糟的是，多个 future 跨线程传递时，未加锁的引用计数或 move 后二次访问极易触发未定义行为。
- 标准
std::future不可拷贝、仅可 move，但 move 后原对象进入有效但未指定状态，.valid()可能返回 false，却无法可靠判断是否已被取值 - 没有内置线程切换机制，所谓“异步链”常退化为同步阻塞链，尤其在
std::launch::deferred策略下 - 异常传播不可控：一个 stage 抛异常，后续 stage 无法自动感知，
std::future::get()外部不捕获就直接 terminate
用 std::promise + std::thread 手搓最简任务链（无第三方依赖）
核心思路是把每个 stage 封装为可执行单元，用 std::promise 控制下游输入，用 std::thread 或线程池解耦执行时机。关键不是“多快”，而是“谁负责 resolve、谁负责调度、谁持有 promise”三者边界清晰。
template<typename t typename u>
auto then(std::future<t> prev, std::function<u> func) -> std::future<u> {
std::promise<u> p;
auto fut = p.get_future();
std::thread([prev = std::move(prev), func = std::move(func), p = std::move(p)]() mutable {
try {
T val = prev.get(); // 阻塞只在此线程内
p.set_value(func(val));
} catch (...) {
p.set_exception(std::current_exception());
}
}).detach(); // 注意：生产环境建议用线程池管理，此处仅为示意
return fut;
}
</u></u></u></t></typename>
- 必须 move
prev和func进线程，否则 lambda 捕获的是栈引用，线程启动后栈已销毁 -
std::thread::detach()是临时方案；真实项目中需用std::shared_ptr管理线程生命周期，或接入boost::asio::thread_pool - 返回的
std::future不支持.wait_for()精确超时，因底层线程无句柄；如需控制，应改用std::packaged_task+ 条件变量
用 std::packaged_task 实现可取消、可重入的任务链
比裸 std::thread 更可控：它把 callable 和 promise 绑定一体，支持移动、可存储到容器，并天然适配线程池。取消能力需额外引入状态标记，不能依赖 future 自身（标准 future 不支持 cancel）。
template<typename t>
class cancellable_task {
std::atomic<bool> cancelled_{false};
std::packaged_task<t> task_;
public:
template<typename f>
explicit cancellable_task(F&& f) : task_(std::forward<f>(f)) {}
void cancel() { cancelled_ = true; }
std::future<t> start() {
auto fut = task_.get_future();
std::thread([this]{
if (!cancelled_) task_();
}).detach();
return fut;
}
};
// 链式调用示例：
auto t1 = cancellable_task<int>([]{ return 42; });
auto t2 = cancellable_task<:string>([fut = t1.start()]{
return "result: " + std::to_string(fut.get());
});
</:string></int></t></f></typename></t></bool></typename>
-
std::packaged_task构造时即绑定 promise，避免手动 new promise / manage lifetime - 取消是协作式：task 内部需定期检查
cancelled_.load()，长耗时计算中要插检查点 - 注意
t1.start()返回的 future 必须在 t2 构造前完成，否则 t2 捕获的是未就绪 future —— 这不是链式，是竞态
真正可用的链式异步模型，绕不开 executor 和 continuation
标准库做不到的事，C++20 的 std::jthread 和 std::stop_token 也没补上。想安全做链式异步，必须接受一个事实：你需要一个 executor 抽象来统一调度策略（inline / thread_pool / io_context），以及 continuation 机制把上一阶段输出自动喂给下一阶段输入。libunifex、cppcoro 或 boost.asio 是目前唯一靠谱路径。
- 例如用
boost::asio::co_spawn+awaitable：每个 stage 是awaitable，用co_await表达依赖，调度由io_context统一管理，异常和取消天然传递 - 手写 executor 最小可行版需实现
execute()和context()，且必须保证同一 executor 下的 continuation 不发生虚假唤醒或丢失 - 别试图用
std::future模拟 continuation —— 它的设计目标就是单次消费、无重试、无调度语义，强行扩展只会让代码越来越难 debug
链式异步的本质不是语法糖，是执行上下文的显式传递。哪个环节没管住线程切换、异常传播或资源释放，那个环节就会在压测时突然暴露。
C++免费学习笔记（深入）：立即使用
在学习笔记中，你将探索 C++ 的入门与实战技巧！
