future、shared_future、packaged_task、promise常用接口总结

1. std::future

std::future<T> 用于异步获取任务的结果,结果只能被获取一次。对象不可复制,但可移动。

关键特性
  • get() 调用后,future 状态失效(valid() 返回 false)。
  • 析构时,若关联的异步结果未就绪且是最后一个引用,可能阻塞等待结果(取决于启动策略)。
常用成员函数
  • get()
    获取结果,调用后 valid() 变为 false。若结果未就绪,阻塞当前线程。
    若任务抛异常,get() 会重新抛出该异常。

    T get(); // T 可能为 void、引用或值类型
    
  • wait()
    阻塞直到任务完成,不获取结果。

    void wait();
    
  • wait_for()
    等待指定时间,返回状态 future_statusreadytimeoutdeferred)。

    template <class Rep, class Period>
    std::future_status wait_for(const std::chrono::duration<Rep, Period>& rel_time);
    
  • wait_until()
    等待到指定时间点,返回状态 future_status

    template <class Clock, class Duration>
    std::future_status wait_until(const std::chrono::time_point<Clock, Duration>& timeout_time);
    
  • valid()
    检查是否关联有效结果(例如未调用 get())。

    bool valid() const noexcept;
    
  • share()
    转为 std::shared_future<T>,允许共享结果。

    std::shared_future<T> share();
    

2. std::shared_future

std::shared_future<T> 允许共享异步结果,可被多次调用 get()。对象可复制。

关键特性
  • get() 可多次调用,每次返回结果的副本(若 T 非引用)。
  • T 为引用类型(如 T&),需注意引用的有效性。
常用成员函数
  • get()
    返回结果副本(若 T 非引用)。若 Tvoid,无返回值。

    const T& get() const;  // T 非 void 时的返回类型可能不同
    
  • wait() / wait_for() / wait_until()
    std::future

  • valid()
    std::future


3. std::packaged_task

std::packaged_task<Function> 包装可调用对象(如函数、lambda),将其结果绑定到 std::future。对象不可复制,但可移动。

关键特性
  • 调用 operator() 后,结果被存储到关联的 future 中。
  • 若多次调用 operator() 或未关联可调用对象,抛出 std::future_error
常用成员函数
  • 构造函数
    需提供可调用对象。默认构造的 packaged_task 为空(valid() == false)。

    explicit packaged_task(Function&& f);
    
  • operator()
    执行任务并存储结果或异常。若已调用过或对象为空,抛出异常。

    void operator()(Args... args);
    
  • get_future()
    返回关联的 std::future<T>。若已调用或对象为空,抛出异常。

    std::future<T> get_future();
    
  • swap()
    交换两个 packaged_task 的内容。

    void swap(packaged_task& other) noexcept;
    
  • reset() (C++11 起)
    重置任务,允许重新绑定新的可调用对象。

    void reset();
    

4. std::promise

std::promise<T> 用于显式设置异步结果或异常,关联的 std::future 可获取结果。对象不可复制,但可移动。

关键特性
  • promise 析构前未设置结果,关联的 future 会收到 std::future_errorbroken_promise)。
  • 可设置结果或异常,但只能设置一次,重复设置抛出 std::future_error
常用成员函数
  • 构造函数
    默认构造的 promise 有效。移动构造函数允许转移所有权。

    promise();
    promise(promise&& other) noexcept;
    
  • set_value()
    设置结果。若 Tvoid,无参调用。

    void set_value(const T& value);
    void set_value(T&& value);
    void set_value(); // 当 T 为 void 时
    
  • set_exception()
    设置异常指针(如捕获的异常通过 std::current_exception())。

    void set_exception(std::exception_ptr p);
    
  • set_value_at_thread_exit()
    设置结果,但延迟到当前线程退出时通知 future

    void set_value_at_thread_exit(const T& value);
    
  • set_exception_at_thread_exit()
    类似 set_value_at_thread_exit,但设置异常。

    void set_exception_at_thread_exit(std::exception_ptr p);
    
  • get_future()
    返回关联的 std::future<T>,只能调用一次。

    std::future<T> get_future();
    
  • swap()
    交换两个 promise 的内容。

    void swap(promise& other) noexcept;
    

总结对比

组件核心功能是否可复制是否可移动结果获取次数特殊行为
std::future单次获取异步结果一次get() 后失效,析构可能阻塞
std::shared_future共享异步结果多次get() 返回副本或引用
std::packaged_task包装可调用对象,绑定结果到 future一次调用 operator() 后结果就绪
std::promise显式设置结果或异常一次未设置结果时析构会触发 broken_promise,可设置延迟通知

关键注意事项

  1. 异常传递:所有组件的 get() 会传递任务中抛出的异常。
  2. 有效性检查:调用 get_future()get()set_value() 前需确保对象有效(如 valid() 返回 true)。
  3. 线程安全:除 std::shared_futureconst 成员函数外,其他组件的方法通常不保证线程安全。
  4. 移动语义std::futurestd::packaged_taskstd::promise 支持移动语义,避免复制。
  5. 生命周期管理:确保 promisepackaged_task 的生命周期长于关联的 future 操作,防止悬空引用。
<think>好的,我现在需要详细系统地介绍C++中的std::async、std::packaged_taskstd::promise在多线程中的作用。首先,我得回忆一下这三个组件的基本概念它们之间的区别。可能用户之前已经问过packaged_task的问题,现在希望更全面地了解这三个工具。 首先,std::async是用来异步执行函数的,它返回一个future对象,可以自动管理线程的创建任务的执行。用户可能想知道它其他两个的区别,比如是否自动启动线程,异常处理等。 接下来是std::packaged_task,它包装了一个可调用对象,允许将任务传递给其他线程,并通过future获取结果。之前已经详细讲过packaged_task,这里需要简要回顾,但重点放在与asyncpromise的对比上。 然后是std::promise,它允许显式设置值或异常,通常与future配对使用,用于更底层的结果传递。可能需要解释promise如何手动控制结果的设置,适合复杂场景。 接下来要考虑它们的共同点不同点。三者都涉及futurepromise模式,但抽象层次不同。async更高级,自动管理线程;packaged_task是任务包装器,需要显式运行;promise是最底层的,需要手动设置结果。 需要分点详细说明每个组件的作用、使用场景、优缺点,可能还要比较它们的异同。比如,async适合简单的异步任务,而promise适用于需要从多个线程设置结果的情况,或者回调函数中传递结果。 另外,需要注意用户可能希望了解如何选择这三个工具,比如在什么情况下用哪个更合适。需要举一些例子,比如使用async快速执行任务,使用packaged_task将任务放入队列,使用promise处理线程间复杂的结果传递。 还要注意异常处理,三者如何处理异常,特别是promise需要显式设置异常,而asyncpackaged_task会自动捕获异常并传递到future。 可能还需要讨论线程管理,比如async的启动策略(deferred vs async),packaged_task需要手动移动到线程,promise可以在任何线程设置值。 最后,总结三者之间的关系适用场景,帮助用户理解如何根据需求选择合适的工具。 现在需要组织这些内容,结清晰,分点讲解每个组件,然后比较它们的异同,再给出使用建议示例。确保使用正确的中文术语,避免技术术语错误,同时保持解释的准确性易懂性。</think>以下是关于C++中`std::async`、`std::packaged_task``std::promise`的详细系统解,重点阐述它们在多线程中的作用、差异及适用场景: --- ### 一、核心目标 三者均基于 **Future/Promise 模式**,实现 **异步计算** 与 **结果传递** 的解耦,但抽象层级适用场景不同: | 组件 | 抽象层级 | 核心能力 | 适用场景 | |---------------------|------------|---------------------------|----------------------------| | `std::async` | 最高 | 自动管理线程任务 | 快速启动简单异步任务 | | `std::packaged_task`| 中间 | 封装任务为可移动对象 | 需要显式控制任务调度的场景 | | `std::promise` | 最低 | 完全手动控制结果传递 | 复杂异步逻辑或跨线程协作 | --- ### 二、`std::async`:自动化异步任务 #### 1. 核心特性 - **一键启动**:通过函数调用直接启动异步任务。 - **自动线程管理**:根据策略(`std::launch::async`或`std::launch::deferred`)决定立即创建线程或延迟执行。 - **隐式结果绑定**:返回`std::future`自动绑定到异步结果。 #### 2. 代码示例 ```cpp #include <future> #include <iostream> int compute(int x) { return x * x; } int main() { auto future = std::async(std::launch::async, compute, 42); // 主线程可继续执行其他操作... std::cout << "Result: " << future.get() << std::endl; // 阻塞等待结果 } ``` #### 3. 关键行为 - **异常传递**:函数中的异常会通过`future.get()`抛出。 - **资源释放**:future时会隐式等待任务完成(若未分离线程)。 #### 4. 适用场景 - 快速执行不依赖线程资源的任务。 - 需要简洁代码实现异步计算。 --- ### 三、`std::packaged_task`:可移动的任务容器 #### 1. 核心特性 - **显式任务封装**:将函数/可调用对象包装为可移动对象。 - **手动调度控制**:需要显式传递任务到线程或线程池。 - **结果绑定**:通过`get_future()`获取关联的`std::future`。 #### 2. 代码示例 ```cpp #include <future> #include <thread> #include <queue> std::queue<std::packaged_task<int()>> task_queue; void worker() { while (!task_queue.empty()) { auto task = std::move(task_queue.front()); task_queue.pop(); task(); // 执行任务,结果自动存储到future } } int main() { std::packaged_task<int()> task([]{ return 42 * 42; }); auto future = task.get_future(); task_queue.push(std::move(task)); std::thread th(worker); th.detach(); std::cout << "Result: " << future.get() << std::endl; } ``` #### 3. 关键行为 - **资源所有权**:任务对象必须通过`std::move`传递。 - **延迟执行**:任务可存储在队列中,按需调度。 #### 4. 适用场景 - 需要将任务排队或批量提交到线程池。 - 需要灵活控制任务执行时机。 --- ### 四、`std::promise`:手动的结果传递通道 #### 1. 核心特性 - **完全手动控制**:通过`set_value()`/`set_exception()`显式传递结果。 - **多线程协作**:可在任意线程设置结果,与任务执行线程解耦。 - **多结果绑定**:一个`promise`可生成多个`future`(通过`shared_future`)。 #### 2. 代码示例 ```cpp #include <future> #include <thread> void compute(std::promise<int>&& prom) { try { int result = 42 * 42; prom.set_value(result); // 显式设置结果 } catch (...) { prom.set_exception(std::current_exception()); // 传递异常 } } int main() { std::promise<int> prom; auto future = prom.get_future(); std::thread th(compute, std::move(prom)); th.detach(); std::cout << "Result: " << future.get() << std::endl; } ``` #### 3. 关键行为 - **结果生命周期**:`promise``future`需保证结果传递期间的有效性。 - **灵活异常处理**:可手动捕获并传递异常。 #### 4. 适用场景 - 需要跨多个线程设置结果(如回调函数)。 - 需要实现自定义的异步通信协议。 --- ### 五、对比总结 | 特性 | `std::async` | `std::packaged_task` | `std::promise` | |---------------------|-------------------------|---------------------------|---------------------------| | **线程管理** | 自动 | 手动(需传递到线程) | 完全手动 | | **结果传递方式** | 隐式(自动绑定) | 半自动(任务执行后存储) | 显式(手动设置) | | **任务封装** | 直接绑定函数 | 封装为可移动对象 | 无封装,需手动关联 | | **灵活性** | 低 | 中 | 高 | | **典型场景** | 简单的一次性异步任务 | 任务队列/线程池调度 | 跨线程协作/复杂回调 | --- ### 六、选择指南 1. **优先使用`std::async`**: - 当任务简单且无需精细控制线程时。 - 示例:后台计算、文件读取等独立任务。 2. **选择`std::packaged_task`**: - 需要将任务存储到容器或跨线程传递时。 - 示例:线程池任务队列、批量任务调度。 3. **使用`std::promise`**: - 需要完全控制结果传递或跨多线程协作时。 - 示例:自定义事件循环、复杂回调链、多生产者单消费者模型。 --- ### 七、综合示例:混合使用三者 ```cpp #include <future> #include <thread> #include <vector> // 使用async快速启动任务 auto fetch_data() { return std::async([]{ return "Data from network"; }); } // 使用packaged_task管理任务队列 void process_data(std::packaged_task<std::string()> task) { task(); } // 使用promise处理回调 void save_to_db(const std::string& data, std::promise<bool> prom) { try { // 模拟数据库操作 prom.set_value(true); } catch (...) { prom.set_exception(std::current_exception()); } } int main() { // 1. async获取数据 auto data_future = fetch_data(); // 2. packaged_task处理数据 std::packaged_task<std::string()> process_task([&]{ return data_future.get() + " processed"; }); auto processed_future = process_task.get_future(); std::thread th1(std::move(process_task)); th1.join(); // 3. promise处理存储结果 std::promise<bool> save_prom; auto save_future = save_prom.get_future(); std::thread th2(save_to_db, processed_future.get(), std::move(save_prom)); th2.detach(); if (save_future.get()) { std::cout << "Complete!" << std::endl; } } ``` --- ### 八、关键注意事项 1. **线程安全**: - `promise``future`的非const方法非线程安全。 2. **生命周期管理**: - 确保`promise`对象在设置结果前有效。 3. **异常处理**: - 未处理的异常会导致`std::future_error`。 4. **性能考量**: - `std::async`默认策略可能延迟执行,需显式指定`std::launch::async`。 通过合理组合这三个工具,可以实现从简单到复杂的多线程异步编程需求。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值