thread,packaged_task,promise

本文深入探讨了C++中Thread, Packaged_task及Promise的运用,通过实例代码展示了如何使用这些并发工具进行线程间通信和同步,是理解C++多线程编程不可或缺的资源。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Thread,Packaged_task,Promise 运用

#include <iostream>
#include <future>
#include <thread>
#include <stdlib.h>
#include <chrono>


int func(std::future<int> &fut)
{
    int val = fut.get();
    std::cout<<"thread "<<std::this_thread::get_id()<<" is going to sleep for "<<val<<" seconds..."<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(val));
    return val;
}

int main()
{
    std::packaged_task<int(std::future<int> &)> packtask(std::ref(func));
    std::promise<int> ap;
    std::future<int> fut = ap.get_future();
    std::thread th(std::move(packtask),std::ref(fut));
    std::cout<<"thread "<<std::this_thread::get_id()<<" is going to sleep for "<<5<<" seconds..."<<std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    ap.set_value(3);
    if(th.joinable())
    {
        th.join();
    }

}
<think>我们正在讨论`std::packaged_task`的异常处理和使用场景。根据引用内容,我们可以总结如下: 1. **异常捕获**:通过`std::future`可以捕获任务执行过程中抛出的异常(引用[2])。 2. **使用场景**:包括任务队列(如线程池)、异步编程等(引用[1]、[2])。 现在,让我们深入探讨`std::packaged_task`的异常处理机制和相关使用场景。 --- ### 一、`std::packaged_task` 异常处理机制 当使用`std::packaged_task`封装任务时,如果任务执行过程中抛出异常,该异常会被捕获并存储到关联的`std::promise`中。随后,当通过`std::future::get()`获取结果时,异常会被重新抛出(在调用`get()`的上下文中)。 #### 1. 异常传递流程 ```cpp #include <iostream> #include <future> #include <stdexcept> int main() { // 封装一个可能抛出异常的任务 std::packaged_task<int()> task([]() -> int { throw std::runtime_error("任务执行失败"); return 42; }); std::future<int> fut = task.get_future(); // 执行任务(会抛出异常,但被packaged_task捕获) task(); // 异常被存储到promise中 try { int result = fut.get(); // 抛出存储的异常 } catch (const std::runtime_error& e) { std::cerr << "捕获异常: " << e.what() << std::endl; // 输出: 捕获异常: 任务执行失败 } return 0; } ``` #### 2. 关键特性 - **异常存储**:任务抛出的任何异常都会通过`std::promise::set_exception()`存储到共享状态中。 - **一次性抛出**:`future::get()`只能获取一次异常(与结果同理),之后`future`变为无效。 --- ### 二、异常处理的使用场景 #### 1. 线程池中的异常安全 在引用[1]和[2]提到的线程池场景中,`packaged_task`可确保工作线程的异常传递到主线程: ```cpp // 线程池任务队列示例 std::queue<std::packaged_task<void()>> tasks; std::mutex queue_mutex; // 工作线程 void worker_thread() { while (true) { std::packaged_task<void()> task; { std::lock_guard<std::mutex> lock(queue_mutex); if (tasks.empty()) continue; task = std::move(tasks.front()); tasks.pop(); } task(); // 执行任务(异常被捕获并存储) } } // 提交任务并获取future template<typename Func> std::future<void> submit_task(Func f) { std::packaged_task<void()> task(f); auto fut = task.get_future(); { std::lock_guard<std::mutex> lock(queue_mutex); tasks.push(std::move(task)); } return fut; } // 使用示例 auto future = submit_task([] { throw std::logic_error("计算错误"); }); try { future.get(); // 在主线程捕获异常 } catch (const std::exception& e) { // 处理异常 } ``` #### 2. 任务重试机制(引用[1]) 通过捕获异常,可实现自动重试: ```cpp void retry_task(std::packaged_task<int()>& task, int max_retries) { for (int i = 0; i < max_retries; ++i) { try { task(); // 执行任务 break; // 成功则退出 } catch (...) { if (i == max_retries - 1) { // 最后一次重试仍失败,存储异常 std::rethrow_exception(std::current_exception()); } } } } ``` #### 3. 异步调用链中的异常传递 结合`std::future`的链式处理: ```cpp std::future<int> async_chain() { std::packaged_task<int()> task1{[] { return 20; }}; auto fut1 = task1.get_future(); // 启动异步任务... // 下一阶段任务(依赖fut1的结果) std::packaged_task<int(int)> task2([](int val) { if (val < 0) throw std::domain_error("值无效"); return val * 2; }); return std::async([fut1 = std::move(fut1), task2 = std::move(task2)]() mutable { try { int input = fut1.get(); // 可能抛出异常 task2(input); return task2.get_future().get(); } catch (...) { // 处理或重新抛出 throw; } }); } ``` --- ### 三、注意事项 1. **任务重置与异常** 引用[2]提到`reset()`方法:仅当任务**未执行过**时才能重置。若任务已执行(无论成功或抛出异常),调用`reset()`会抛出`std::future_error`(错误码`no_state`)。 2. **共享状态生命周期** `packaged_task`析构时,若共享状态未被提取(即未调用`get_future()`)或未执行,其析构行为是安全的。但若已关联`future`且未执行,析构可能导致`future`变为无效状态。 3. **与`std::async`的对比** 引用[4]指出,`std::async`内部使用`packaged_task`,但自动处理了线程启动和异常传递。直接使用`packaged_task`更适合需要手动控制任务调度(如线程池)的场景。 --- ### 四、相关问题 1. 如何在`std::packaged_task`中捕获特定类型的异常并转换为错误码? 2. `std::packaged_task`与`std::function`在异常处理上有何区别? 3. 在多级任务链中,如何设计异常传播机制以避免丢失原始异常信息? 4. 当任务在销毁前未执行,关联的`std::future`会处于什么状态? 5. 如何结合`std::packaged_task`和`std::shared_future`实现多订阅者的异常广播? > 引用来源: > `std::packaged_task` 的异常传递机制 [^3] > 线程池中的异常安全设计 [^1][^2] > 异步任务链的异常处理模式 [^4]</think>### `std::packaged_task` 异常处理机制与使用场景 #### 一、异常处理机制 1. **异常捕获与传递** `std::packaged_task` 会自动捕获任务执行中抛出的异常,并通过关联的 `std::future` 传递: ```cpp #include <future> #include <iostream> #include <stdexcept> int main() { // 封装可能抛出异常的任务 std::packaged_task<int()> task([] { throw std::runtime_error("Task failed!"); return 42; }); std::future<int> fut = task.get_future(); task(); // 执行任务(抛出异常) try { int result = fut.get(); // 此处重新抛出异常 } catch (const std::runtime_error& e) { std::cerr << "捕获异常: " << e.what() << std::endl; // 输出: 捕获异常: Task failed! } } ``` 2. **关键特性**: - **异常存储**:异常被存储到共享状态中,直到调用 `future::get()` 时抛出 - **一次性抛出**:与结果值相同,异常只能通过 `get()` 获取一次 - **状态一致性**:抛出异常后,`future` 状态变为 `ready`,`valid()` 返回 `false` #### 二、异常处理相关使用场景 1. **线程池中的错误处理** 在任务队列中捕获工作线程的异常(引用[1][2]): ```cpp // 线程池任务提交函数 template<typename Func> std::future<void> ThreadPool::submit(Func f) { std::packaged_task<void()> task(f); auto fut = task.get_future(); { std::lock_guard<std::mutex> lock(queue_mutex); tasks.emplace(std::move(task)); // 加入任务队列 } return fut; // 返回future供调用方捕获异常 } // 使用示例 auto future = pool.submit([] { if (error_condition) throw std::logic_error("计算错误"); }); try { future.get(); // 主线程捕获异常 } catch (const std::exception& e) { // 处理异常 } ``` 2. **异步任务链的异常传递** 构建任务链时实现异常穿透: ```cpp auto task1 = std::packaged_task<int()>{ [] { throw std::overflow_error("第一阶段错误"); return 100; }}; auto fut1 = task1.get_future(); std::thread(std::move(task1)).detach(); // 第二阶段任务(依赖第一阶段结果) auto task2 = std::packaged_task<void()>{ [fut = std::move(fut1)] { try { int val = fut.get(); // 此处会抛出第一阶段的异常 } catch (...) { // 捕获并处理 // 记录日志或转换异常类型 throw std::runtime_error("任务链中断"); } }}; ``` 3. **任务重试机制**(引用[1]) 通过异常触发重试逻辑: ```cpp void retry_task(std::packaged_task<void()>& task, int max_retries) { for (int i = 0; i < max_retries; ++i) { try { task(); // 执行任务 return; // 成功则退出 } catch (...) { if (i == max_retries - 1) { // 最后一次重试仍失败,存储异常 std::rethrow_exception(std::current_exception()); } task.reset(); // 重置任务状态(引用[2]) } } } ``` #### 三、关键注意事项 1. **`reset()` 的异常限制**(引用[2]) - 仅当任务**未执行过**时才能调用 `reset()` - 若任务已抛出异常后调用 `reset()`,会抛出 `std::future_error`(错误码 `no_state`) 2. **异常类型保留** `future::get()` 会精确保留原始异常类型,包括自定义异常: ```cpp struct CustomError : std::exception { ... }; std::packaged_task<void()> task([] { throw CustomError(); }); try { task(); task.get_future().get(); } catch (const CustomError& e) { // 精确捕获 // 处理自定义异常 } ``` 3. **与 `std::async` 的对比**(引用[4]) `std::async` 内部使用 `packaged_task` 但自动处理异常传递,更适合简单场景: ```cpp // 等效于手动packaged_task的方案 auto fut = std::async([] { throw std::bad_alloc(); }); fut.get(); // 自动传递异常 ``` #### 四、最佳实践 1. **始终检查任务状态** ```cpp if (task.valid()) { try { task(); auto result = task.get_future().get(); } catch (...) { ... } } ``` 2. **异常安全包装器** ```cpp template<typename Func> auto safe_package(Func f) { std::packaged_task<std::invoke_result_t<Func>()> task([f] { try { return f(); } catch (...) { // 添加额外日志记录 throw; // 重新抛出 } }); return task; } ``` --- ### 相关问题 1. 如何通过 `std::packaged_task` 实现跨线程的异常堆栈追踪? 2. `std::packaged_task` 与 `std::promise` 在异常处理上有何性能差异? 3. 当任务在销毁前未执行,关联的 `std::future` 会抛出什么异常? 4. 如何设计支持异常传播的异步任务链? 5. 在分布式系统中如何通过 `std::packaged_task` 传递序列化异常? > 引用来源: > `std::packaged_task` 的异常捕获机制 [^3] > 线程池中的异常安全实践 [^1][^2] > `std::async` 的异常封装实现 [^4]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值