std::future和std::promise不能直接链式调用，因其future为一次性消费对象，get()/wait()后状态失效，且无.then()机制；需手动通过promise::set_value()调度或封装then模板模拟链式。
为什么 std::future 和 std::promise 不能直接链式调用
因为 std::future 是一次性消费型对象：调用 get() 或 wait() 后，再次访问会抛出 std::future_error: No state。它不提供类似 JavaScript 的 .then() 接口，也没法把前一个 future 的结果自动传给下一个异步任务。
常见错误是写成这样：
auto f1 = std::async([]{ return 42; });
auto f2 = std::async([f = std::move(f1)]{ return f.get() * 2; }); // 错！f1 已被 move，但 f.get() 可能还没 ready，且 f 是 copy/move 后的 future，状态已失效
- 不能靠拷贝
std::future实现链式——拷贝构造在 C++11 后已被删除（仅支持 move） - 不能在 lambda 捕获中直接
.get()，除非你确定它已就绪，否则线程会阻塞，失去“异步”意义 -
std::promise本身不执行任务，只是状态容器；真正要链式，得靠手动调度 + 状态传递
用 std::thread + std::promise 手动实现最简链式
核心思路：前一个任务完成时，用 std::promise::set_value() 触发下一个任务启动。每个环节自己管理线程、promise 和 future 的生命周期。
例如实现「读文件 → 解析 JSON → 计算哈希」三段链：
std::promise<:string> p1;
auto f1 = p1.get_future();
<p>std::promise<:json> p2;
auto f2 = p2.get_future();</:json></p>
<p>std::promise<:string> p3;
auto f3 = p3.get_future();</:string></p>
<p>// 第一环：异步读文件
std::thread t1([&p1]{
std::string content = read_file_async("config.json");
p1.set_value(std::move(content)); // 注意 move，避免拷贝大字符串
});</p>
<p>// 第二环：等 f1 就绪后解析
std::thread t2([&f1, &p2]{
f1.wait(); // 或用 f1.wait_for(...) 防死锁
auto json = nlohmann::json::parse(f1.get());
p2.set_value(std::move(json));
});</p>
<p>// 第三环：等 f2 就绪后计算
std::thread t3([&f2, &p3]{
f2.wait();
auto hash = compute_hash(f2.get().dump());
p3.set_value(std::move(hash));
});
</p></:string>
- 每个
std::promise必须和对应std::future成对出现，且promise对象生命周期必须长于其set_value()调用点 - 务必用
wait()或带超时的wait_for()，不要裸调get()，否则可能因 promise 未 set 导致程序终止 - 所有线程需显式
join()或detach()，否则析构时会std::terminate
用 std::async + 包装函数模拟链式（无额外线程管理）
如果你不想手动管线程，可以用包装函数把「上一个 future 的结果」作为参数传入下一个 std::async，但要注意：这仍是串行等待，不是真正并行链式，只是语法糖。
关键技巧是让每个阶段返回 std::future<t></t>，并用 std::move 传递前序结果：
template<typename f typename... args>
auto then(std::future<typename std::result_of>::type>&& prev, F&& f) {
return std::async(std::launch::async, [prev = std::move(prev), f = std::forward<f>(f)]() mutable {
return f(prev.get()); // 此处 get() 是同步等待，但封装在 async 内部，调用方仍可继续
});
}
<p>// 使用：
auto f = std::async([]{ return 123; });
auto g = then(std::move(f), [](int x){ return x * 2; });
auto h = then(std::move(g), [](int x){ return std::to_string(x); });</p>
<p>std::cout </p>
<ul>
<li>这个 <code>then()</code> 不是标准库函数，是手写的辅助模板；它内部仍依赖 <code>.get()</code>，所以每个环节实际是“前一个完成才启动下一个”</li>
<li>如果想真正并发（比如多个分支同时处理同一输入），得用多个 <code>std::async</code> 共享同一个 <code>std::shared_future</code>
</li>
<li>注意返回类型推导：C++14 后可用 <code>auto</code>，但若函数有重载或模板歧义，需显式指定返回 future 类型</li>
</ul>
<h3>容易被忽略的资源泄漏与异常安全点</h3>
<p>最常漏掉的是：promise 设置失败时没调用 <code>set_exception()</code>，导致下游 future 永远 wait 不到结果。</p>
<ul>
<li>任何可能抛异常的环节（如 JSON 解析失败、文件读取 IO 错误），都必须包裹 <code>try/catch</code> 并调用 <code>promise::set_exception(std::current_exception())</code>
</li>
<li>
<code>std::promise</code> 对象不能是局部变量且被异步 lambda 捕获——lambda 捕获的是引用或值，若 promise 析构早于 <code>set_value()</code>，会 crash</li>
<li>如果链路很长，建议用 <code>std::shared_ptr<:promise>></:promise></code> 管理生命周期，尤其当多个线程可能触发同一 promise 时</li>
<li>别在主线程里连续创建几十个 <code>std::async</code>，默认 launch policy 是 <code>async|deferred</code>，系统可能退化为 deferred（即同步执行），导致卡住</li>
</ul>
<p>链式异步真正的复杂点不在语法，而在于状态归属、异常传播路径和线程生存期的精确控制——写完记得检查每处 <code>promise</code> 是否一定被 set，每处 <code>future</code> 是否一定被 get 或 wait，以及每个线程是否被正确回收。</p></f></typename></typename>C++免费学习笔记（深入）：立即使用
在学习笔记中，你将探索 C++ 的入门与实战技巧！
