C++ std::promise 原理与实战解析

关键注意点

• future::get() 是一次性操作：一旦调用 get() 获取到结果（值/异常），共享状态的结果会被转移（或拷贝，视类型而定），后续再次调用 get() 会触发未定义行为（可使用 std::shared_future 支持多次获取）；
• 若 promise 未设置值/异常就被销毁，共享状态会被标记为「异常就绪」，此时 future::get() 会抛出 std::future_error 异常（错误码：std::future_errc::broken_promise）。

四、promise 的模板特化

std::promise 提供了三个版本的实现（主模板 + 两个特化），以支持不同的结果类型，特化的核心目的是适配「引用类型」和「无返回值（void）」的场景，仅对 set_value/set_value_at_thread_exit 的参数做调整，其余功能（如共享状态、与 future 协作、异常处理）与主模板完全一致：

1. 主模板：template promise

适配普通值类型（如 int/std::string/自定义类型），set_value() 需传入T 类型的对象（值传递/移动传递），示例：

std::promise<int> prom; prom.set_value(10);// 传入 int 类型值，写入共享状态

2. 引用特化：template promise<R&>

适配引用类型（如 int&/std::string&），set_value() 需传入R 类型的左值（而非 R&），用于将共享状态绑定到一个已存在的对象，示例：

int x = 20; std::promise<int&> prom; prom.set_value(x);// 传入 int 左值，共享状态存储该对象的引用 std::future<int&> fut = prom.get_future();int& ref = fut.get();// ref 是 x 的引用，修改 ref 即修改 x

3. void 特化：template <> promise

适配「无返回值」场景，set_value()无参数，仅用于将共享状态标记为「就绪」，实现纯同步（无需传递值，仅通知消费者任务完成），示例：

std::promise<void> prom; std::future<void> fut = prom.get_future();// 工作线程等待：仅等待状态就绪，无值可获取 std::thread th([&fut](){ fut.wait(); std::cout << "任务完成！\n";}); prom.set_value();// 无参数，仅将共享状态置为就绪，唤醒工作线程 th.join();

五、promise 的核心成员函数

promise 的所有成员函数都是围绕操作共享状态设计的，核心函数可分为「关联 future」「设置结果」「辅助操作」三类，均为公有成员函数，关键函数说明如下：

1. 关联 future：get_future()

• 功能：返回一个与当前 promise 共享状态绑定的 std::future<T> 对象；
• 注意：一个 promise 只能调用一次 get_future()，多次调用会抛出 std::future_error 异常（错误码：std::future_errc::future_already_retrieved）。

2. 设置结果（核心生产操作）

这类函数的核心作用是修改共享状态：将值/异常写入共享状态，并将状态置为「就绪」，唤醒阻塞线程，分为「立即生效」和「线程退出时生效」两类：

3. 辅助操作

• swap(promise& other)：交换两个 promise 的共享状态，无拷贝，仅交换内部指针，效率极高；
• 移动构造/移动赋值（promise(promise&&)/promise& operator=(promise&&)）：promise 是不可拷贝的（拷贝构造/拷贝赋值被删除），仅支持移动，移动后原 promise 不再关联任何共享状态；
• 析构函数：销毁 promise，若其仍关联共享状态且状态为「未就绪」，则将共享状态标记为「异常就绪」（抛出 broken_promise 异常），并减少共享状态的引用计数。

六、关键特性总结

1. 不可拷贝，仅可移动：promise 的拷贝构造和拷贝赋值被显式删除，只能通过移动语义转移所有权，避免多个 promise 操作同一个共享状态导致的冲突；
2. 结果唯一性：一个 promise 只能设置一次值或异常，多次调用 set_value()/set_exception() 会抛出 std::future_error 异常；
3. 线程安全：promise 的所有成员函数都是线程安全的，多个线程可同时操作一个 promise（但实际场景中通常一个 promise 由一个生产者线程操作）；
4. 异常传递：支持通过 std::exception_ptr 跨线程传递异常，future::get() 会自动重新抛出该异常，实现异常的跨线程传播；
5. 纯同步支持：通过 promise<void> 可实现无结果的纯线程同步，仅通过共享状态的就绪状态实现阻塞与唤醒。

七、经典使用示例（含值传递 + 异常传递）

1. 基础值传递（对应开篇示例）

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

// 消费者线程：通过 future 获取值
void consumer(std::future<int>& fut){
    try{
        int val = fut.get();// 阻塞等待，直到共享状态就绪 
        std::cout << "消费者获取到值：" << val << std::endl;
    }catch(const std::exception& e){
        std::cout << "消费者捕获异常：" << e.what()<< std::endl;
    }
}

int main(){
    std::promise<int> prom;// 创建 promise，生成共享状态 
    std::future<int> fut = prom.get_future();// 绑定 future
    // 启动消费者线程，传递 future（std::ref 避免拷贝）
    std::thread th(consumer, std::ref(fut));
    // 生产者设置值，将共享状态置为就绪，唤醒消费者
    prom.set_value(100);
    th.join();
    return 0;
}
// 输出：消费者获取到值：100

2. 跨线程异常传递

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

void consumer(std::future<int>& fut){
    try{
        int val = fut.get();
        std::cout << "消费者获取到值：" << val << std::endl;
    }catch(const std::runtime_error& e){
        std::cout << "消费者捕获运行时异常：" << e.what()<< std::endl;
    }catch(const std::future_error& e){
        std::cout << "消费者捕获 future 异常：" << e.what()<< std::endl;
    }
}

int main(){
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread th(consumer, std::ref(fut));
    // 生产者设置异常，替代值传递
    prom.set_exception(std::make_exception_ptr(std::runtime_error("计算失败：除数为 0")));
    th.join();
    return 0;
}
// 输出：消费者捕获运行时异常：计算失败：除数为 0

八、底层原理补充：阻塞与唤醒的实现

共享状态的「阻塞 - 唤醒」是实现 future::get() 阻塞等待的核心，其底层依赖操作系统的同步原语（如 POSIX 下的 pthread_cond_t 条件变量 +pthread_mutex_t 互斥锁，Windows 下的 CONDITION_VARIABLE+CRITICAL_SECTION），核心逻辑如下：

1. 当线程调用 future::get() 时，先加锁保护共享状态，检测状态是否为「就绪」；
2. 若未就绪，将当前线程加入共享状态的等待队列，然后解锁并阻塞（调用条件变量的 wait() 方法，原子性完成「解锁 + 阻塞」，避免竞态）；
3. 当 promise 设置值/异常后，加锁修改共享状态为「就绪」，然后通过条件变量唤醒等待队列中的所有线程；
4. 被唤醒的线程重新加锁，检测共享状态是否就绪，确认后解锁并读取结果，完成操作。

该实现保证了「无忙等」，阻塞的线程不会占用 CPU 资源，是高效的线程同步方式。

核心总结

1. std::promise 是异步结果生产者，与 std::future 配对实现跨线程的结果传递和同步，核心依赖共享状态；
2. 共享状态是线程安全的堆对象，独立管理生命周期，是 promise 和 future 的通信载体，存储结果（值/异常）和状态；
3. promise 提供三个版本（主模板 +R&/void 特化），仅适配结果类型，底层逻辑一致，支持值、引用、无返回值三种场景；
4. 核心协作流程：promise 创建共享状态 → future 绑定状态 → 消费者阻塞 → 生产者设置结果（置就绪 + 唤醒）→ 消费者获取结果；
5. 关键特性：不可拷贝仅可移动、结果唯一、线程安全、支持异常跨线程传递，是 C++ 异步编程的基础组件。