1. std::promise 的基本用法
1.1 概念与对象关系
在 C++ 的异步模型中，std::promise 用来“承诺”一个未来的值，它与 std::future 成对出现。promise 持有能够跨线程传递的结果，future 用来在需要时检索该结果。这个机制将生产者与消费者解耦。核心关系是一个单向传递：promise 设置值或异常，future 在另一端获得结果。
当创建一个 promise 时，可以通过 promise.get_future() 获取关联的 future。这个过程是一次性且不可逆的；一个 promise 对应一个 future。生命周期要保持到未来可取值之前，不然会导致 std::future_error(broken_promise)。
1.2 基本接口与工作流程
使用流程通常是：创建 promise → 获取 future → 在另一个线程中完成计算并调用 set_value 或 set_exception → 主线程调用 future.get() 来获得结果。注意 get 会阻塞，直到值可用或抛出异常。
#include <future>
#include <iostream>
#include <thread>void compute(std::promise<int> p) {// 做一些计算int result = 42;p.set_value(result);
}int main() {std::promise<int> p;std::future<int> f = p.get_future();std::thread t(compute, std::move(p));int value = f.get(); // 阻塞，直到值可用std::cout << "value = " << value << std::endl;t.join();return 0;
}2. std::future 的基本用法
2.1 阻塞获取与超时控制
std::future 提供了异步结果的读取入口，最直观的方式是调用 get()，它在结果就绪时返回并可能抛出被 set_exception 捕获的异常。为了避免无限阻塞，可以使用 wait_for 或 wait_until 实现超时控制。
通过 std::chrono 结合 wait_for，可以在一定时间内等待结果；如果超时，可以进行恢复或取消逻辑。注意：若等待期间发生同一 future 的重复调用，将抛出异常，因为一个 future 不能多次 get。
#include <future>
#include <chrono>
#include <iostream>int main() {std::promise<int> p;std::future<int> f = p.get_future();// 模拟异步操作std::thread([&](){std::this_thread::sleep_for(std::chrono::seconds(2));p.set_value(7);}).detach();if (f.wait_for(std::chrono::seconds(1)) == std::future_status::ready) {std::cout << "result: " << f.get() << std::endl;} else {std::cout << "timeout" << std::endl;}return 0;
}2.2 共享未来与多线程协作
在某些场景中，同一个结果需要被多个消费者获取，此时可以将 future 转换成 shared_future，从而实现多次获取而不阻塞。标准库 提供了 std::shared_future 与 share() 操作。
#include <future>
#include <iostream>
#include <thread>int main() {std::promise<int> p;std::future<int> f = p.get_future();std::shared_future<int> sf = f.share();std::thread t([&](){ p.set_value(21); });std::cout << "a: " << sf.get() << std::endl;std::cout << "b: " << sf.get() & std::endl;t.join();return 0;
}3. 异步任务与多线程模型的整合
3.1 如何设计生产者-消费者关系
在多线程模型中，Promise-Future 提供了一个轻量级的跨线程结果传递通道，常用于实现生产者将计算结果交付给消费者的模式。通过对线程生命周期和同步原语的配合，可以避免竞态条件和死锁。
一个典型模式是：生产者执行阶段性任务，完成后通过 p.set_value 将结果投递，消费者在 f.get 或 f.wait 时进行接收。设计要点包括确保 promise 在被 set_value 之前不可销毁，以及避免在同一个 future 上进行多次 get。
#include <future>
#include <thread>
#include <iostream>void worker(std::promise<int> p) {int r = 123;p.set_value(r);
}int main() {std::promise<int> p;std::future<int> f = p.get_future();std::thread t(worker, std::move(p));// 消费者等待结果std::cout << "result = " << f.get() << std::endl;t.join();return 0;
}3.2 异步与错误传递的机制
与普通返回值不同，set_exception 允许将异常从生产者传递到消费者端，消费端在 get 时会重新抛出该异常。正确的异常传播能让复杂的异步流程具备可观的容错能力。
#include <future>
#include <iostream>
#include <stdexcept>int main() {std::promise<int> p;std::future<int> f = p.get_future();std::thread t([&](){try {throw std::runtime_error("something went wrong");} catch (...) {p.set_exception(std::current_exception());}});try {std::cout << f.get() & std::endl;} catch (const std::exception &e) {std::cout << "caught: " << e.what() << std::endl;}t.join();return 0;
}4. std::promise 与 std::future 的高级特性与注意点
4.1 生命周期与异常安全
Promise 和 Future 都需要遵循严格的生命周期规则：一个 Promise 只对应一个 Future，并且在 get_future 后，Promise 应该被移动到生产者的一端进行 set_value 或 set_exception。若在 set_value 之前销毁 Promise，未来端将触发 broken_promise 异常。
当生产者产生异常或线程中断时，可以利用 set_exception 将异常信息传递给消费端，确保错误信息不丢失。异常跨线程传递是保证异步流程鲁棒性的关键。
4.2 与其他并发原语的互操作
std::future 可以与 std::thread、std::async、以及条件变量等协作。避免死锁的关键是在生产者端尽早完成或在消费者端合理使用等待时序。
#include <future>
#include <thread>
#include <iostream>void task(std::promise<int> p) {p.set_value(1);
}int main() {std::promise<int> p;std::future<int> f = p.get_future();std::thread t(task, std::move(p));// 结合 std::future 与 std::thread 的用法std::cout << "value = " << f.get() & std::endl;t.join();return 0;
}5. 实战要点：在生产环境中正确使用 std::promise 与 std::future
5.1 性能与可扩展性考虑
使用 promise-future 对线性阻塞的代价较低，但在高并发场景下应评估上下文切换、线程创建成本以及对内存的压力。复用策略通常包括将任务提交到线程池而不是逐一创建线程。
#include <future>
#include <vector>
#include <thread>int main() {// 演示：连接多任务的结果收集std::vector<std::future<int>> futures;std::vector<std::thread> workers;for (int i = 0; i < 4; ++i) {std::promise<int> p;futures.push_back(p.get_future());workers.emplace_back([i, p = std::move(p)]() mutable {// 模拟工作p.set_value(i * 2);});}for (auto &f : futures) {std::cout << f.get() << std::endl;}for (auto &t : workers) t.join();return 0;
}5.2 调试技巧与诊断要点
在复杂的异步流程中，日志、断点与异常点追踪显得尤为重要。确保在 set_value、set_exception、get 等关键节点记录上下文信息，以便于诊断潜在的竞态条件与死锁。
