std::future、std::promise、std::async 和 std::packaged_task涉及到的异常存储机制

在C++的并发编程中，std::future、std::promise、std::async 和 std::packaged_task 共同构成了异常安全的异步操作框架。以下是它们处理异常的核心机制及相互关系：

一、异常存储的核心机制

1. 共享状态（Shared State）

• 中央存储：所有异常和结果都存储在 future 关联的共享状态中。
• 线程安全：状态的读写自动同步，无需额外锁。

2. 异常传递路径

操作抛出异常 ──> promise.set_exception() ──> 存储到共享状态 ──> future.get() 重新抛出

3. 关键接口

• 设置异常：

  std::promise<int> prom;
  try {
      throw std::runtime_error("Error occurred");
  } catch (...) {
      prom.set_exception(std::current_exception());  // 捕获并存储异常
  }
  

• 获取异常：

  std::future<int> fut = prom.get_future();
  try {
      int value = fut.get();  // 若共享状态存储异常，此处重新抛出
  } catch (const std::exception& e) {
      std::cerr << "Caught: " << e.what() << std::endl;
  }
  

二、各组件的异常处理角色

1. std::promise

• 异常生产者：通过 set_exception() 显式设置异常。
• 示例：

  void worker(std::promise<int>& prom) {
      try {
          if (failed_condition) {
              throw std::runtime_error("Operation failed");
          }
          prom.set_value(42);
      } catch (...) {
          prom.set_exception(std::current_exception());  // 捕获所有异常并传递
      }
  }
  

2. std::packaged_task

• 自动捕获异常：任务执行时抛出的异常会自动存储到共享状态。
• 示例：

  std::packaged_task<int()> task([]{
      if (error_condition) {
          throw std::logic_error("Invalid operation");
      }
      return 100;
  });
  
  std::future<int> fut = task.get_future();
  task();  // 若任务抛出异常，future会自动接收
  
  try {
      int result = fut.get();  // 重新抛出异常
  } catch (const std::logic_error& e) {
      std::cerr << e.what() << std::endl;
  }
  

3. std::async

• 透明异常传递：异步任务中的异常会在调用 future.get() 时重新抛出。
• 示例：

  auto fut = std::async([]{
      throw std::runtime_error("Async error");
      return 0;
  });
  
  try {
      int value = fut.get();  // 此处抛出 std::runtime_error
  } catch (const std::exception& e) {
      std::cerr << "Async exception: " << e.what() << std::endl;
  }
  

三、异常处理的关键特性

1. 异常类型保留

• 原始异常类型（如 std::runtime_error）会被完整保留，可通过 catch 精确捕获。

2. 一次性异常

• 共享状态只能存储一个异常或值，多次设置会抛出 std::future_error。

3. 生命周期安全

• 即使 promise 或 packaged_task 被销毁，异常仍会保留在共享状态中。

四、最佳实践

1. 确保异常被设置

• 使用 try-catch 包裹可能抛出异常的代码：

  void producer(std::promise<void>& prom) {
      try {
          // 可能抛出异常的操作
          prom.set_value();  // 正常完成
      } catch (...) {
          prom.set_exception(std::current_exception());  // 异常处理
      }
  }
  

2. 异常与超时结合

• 使用 wait_for() 检测异常是否就绪：

  if (fut.wait_for(std::chrono::seconds(1)) == std::future_status::ready) {
      try {
          fut.get();  // 安全获取结果或异常
      } catch (...) {
          // 处理异常
      }
  }
  

3. 自定义异常类型

• 抛出自定义异常类以携带更多上下文信息：

  class NetworkError : public std::runtime_error {
  public:
      NetworkError(const std::string& msg) : std::runtime_error(msg) {}
  };
  
  // 抛出异常
  throw NetworkError("Connection timeout");
  
  // 捕获特定异常
  try {
      fut.get();
  } catch (const NetworkError& e) {
      std::cerr << "Network error: " << e.what() << std::endl;
  }
  

五、组件关系总结

组件	角色	异常处理方式
std::promise	手动控制共享状态	通过 set_exception() 显式设置
std::packaged_task	封装可调用对象	自动捕获任务执行中的异常
std::async	高层异步接口	透明传递异步函数的异常
std::future	结果/异常消费者	通过 get() 重新抛出异常

六、典型场景示例

1. 异步文件读取

auto fut = std::async([]{
    std::ifstream file("data.txt");
    if (!file.is_open()) {
        throw std::runtime_error("Failed to open file");
    }
    // 读取文件内容
});

try {
    fut.get();  // 处理文件读取或异常
} catch (const std::runtime_error& e) {
    std::cerr << "File error: " << e.what() << std::endl;
}

2. 多任务并行处理

std::vector<std::future<void>> futures;
for (auto& task : tasks) {
    futures.push_back(std::async([&task]{
        task.execute();  // 可能抛出异常
    }));
}

// 等待所有任务完成并处理异常
for (auto& fut : futures) {
    try {
        fut.get();
    } catch (const std::exception& e) {
        std::cerr << "Task error: " << e.what() << std::endl;
    }
}

七、注意事项

1. 异常与析构顺序：

   • 若 promise 在设置异常前被销毁，future.get() 会抛出 broken_promise。

2. 异常与移动语义：

   • promise 和 packaged_task 不可复制，需通过 std::move 转移所有权。

3. 异常与线程池：

   • 在线程池实现中，需确保所有任务路径都能正确设置异常或结果。

通过这种异常存储和传递机制，C++的异步框架提供了类型安全、线程安全的错误处理方案，使开发者能够像处理同步代码一样优雅地处理异步操作中的异常。

补充

这段内容详细解释了 C++ 中 std::future 存储异常的机制，以及它与 std::promise、std::async 和 std::packaged_task 的交互方式。以下是关键要点的解读：

一、异常存储的核心机制

1. 自动捕获异常
   当 std::async 或 std::packaged_task 执行的函数抛出异常时，异常会被自动捕获并存储在 future 中：

   auto fut = std::async([]{
       throw std::runtime_error("Task failed");  // 异常自动存储到future
       return 42;
   });
   
   // 调用get()时重新抛出异常
   try {
       fut.get();  // 抛出std::runtime_error
   } catch (const std::runtime_error& e) {
       std::cerr << e.what() << std::endl;
   }
   

2. 显式设置异常（std::promise）
   使用 set_exception() 手动存储异常，通常在 catch 块中使用：

   std::promise<int> prom;
   try {
       throw std::logic_error("Invalid operation");
   } catch (...) {
       prom.set_exception(std::current_exception());  // 存储当前异常
   }
   
   // 后续get()会重新抛出存储的异常
   

二、三种异常存储方式对比

方式	适用场景	示例代码
自动捕获	std::async 或 packaged_task	auto fut = std::async([]{ throw ... });
显式设置	std::promise	prom.set_exception(std::current_exception());
构造异常指针	已知异常类型，无需捕获	prom.set_exception(std::make_exception_ptr(std::logic_error("foo")));
未设置值即销毁	promise/task生命周期管理失败	{ std::promise p; } // 未set_value即销毁，future抛出broken_promise

三、关键技术细节

1. 异常对象的复制/移动

   • 标准未强制要求抛出原始异常对象还是副本，具体实现由编译器决定。
   • 实际应用中，异常对象通常会被复制或移动到共享状态中。

2. std::current_exception() vs std::make_exception_ptr()

   • current_exception()：捕获当前正在处理的异常，用于 catch 块中。
   • make_exception_ptr()：直接创建异常指针，无需抛出异常，代码更简洁：

     // 直接构造异常，无需try/catch
     prom.set_exception(std::make_exception_ptr(std::runtime_error("Manual error")));
     

3. broken_promise 异常
   若 promise 或 packaged_task 被销毁前未设置值或异常，future 会抛出：

   {
       std::promise<int> p;
       std::future<int> f = p.get_future();
   }  // p被销毁，未设置值
   f.get();  // 抛出std::future_error，错误码为broken_promise
   

四、最佳实践

1. 优先使用 make_exception_ptr()
   当异常类型已知时，直接构造异常指针更高效：

   if (error_condition) {
       prom.set_exception(std::make_exception_ptr(std::invalid_argument("Bad input")));
       return;
   }
   

2. 确保异常被正确设置
   使用 RAII 模式或 try-finally 确保 promise 始终被设置：

   void worker(std::promise<int>& p) {
       try {
           // 可能抛出异常的操作
           p.set_value(42);
       } catch (...) {
           p.set_exception(std::current_exception());
       }
   }
   

3. 避免悬空 future
   确保 future 的生命周期不超过其关联的 promise 或 packaged_task：

   std::future<int> f;
   {
       std::promise<int> p;
       f = p.get_future();
       // 错误：p在此处销毁，f变为broken_promise
   }
   

五、异常处理流程总结

异常抛出 ───> 被捕获并存储到future的共享状态 ───> 调用future.get() ───> 重新抛出异常
                    ↑
         ┌──────────┼──────────┐
         │          │          │
    自动捕获   显式调用set_exception()   未设置即销毁
    (async/task)      (promise)         (broken_promise)

六、注意事项

1. 线程安全
   异常存储操作是线程安全的，多个线程可同时访问同一个 future。

2. 异常与值的互斥性
   共享状态只能存储一个异常或值，多次设置会抛出 future_error。

3. 超时处理
   使用 wait_for() 检查异常是否就绪，避免永久阻塞：

   if (fut.wait_for(std::chrono::seconds(1)) == std::future_status::ready) {
       try {
           fut.get();  // 安全获取结果或异常
       } catch (...) { /* 处理异常 */ }
   }
   

通过这种机制，C++ 的异步框架提供了统一的异常处理模型，使开发者能够像处理同步代码一样优雅地处理异步操作中的错误。