C++ `std::exception_ptr`：跨线程传递异常的机制

好的，咱们今天就来聊聊 C++ 里一个挺有意思的家伙：std::exception_ptr。这家伙专治各种不服，尤其是那些想跨线程搞事情的异常。

开场白：异常，线程，和那些不得不说的故事

各位听众，你们有没有遇到过这样的场景：主线程辛辛苦苦跑着，突然某个后台线程炸了，抛了个异常。你心想：没事，我抓一下，报告个错误，顶多重启一下。结果呢？抓了个寂寞！异常根本没影儿了！

这就是线程之间的恩怨情仇。异常这东西，默认情况下，它就乖乖地待在自己被抛出的线程里，除非你采取一些措施，否则它才懒得跨线程跟你玩。

std::exception_ptr，就是为了解决这个问题而生的。它就像一个“异常快递员”，负责把一个线程里的异常打包好，安全地送到另一个线程里。

std::exception_ptr 是个啥？

简单来说，std::exception_ptr 是一个智能指针，它指向的是一个异常的拷贝。注意，是拷贝！

你可以把它想象成一个“异常快照”，把你想要传递的异常的状态冻结起来，然后通过这个指针，你就可以在另一个线程里重新抛出这个异常，或者查看异常的信息。

怎么用？上代码！

咱们先来个最简单的例子，看看 std::exception_ptr 怎么把一个异常从一个线程送到另一个线程：

#include <iostream>
#include <thread>
#include <exception>
#include <stdexcept>

std::exception_ptr global_exception; // 全局异常指针

void worker_thread() {
  try {
    // 模拟一个可能抛出异常的操作
    throw std::runtime_error("Oops! Something went wrong in the worker thread.");
  } catch (...) {
    // 捕获异常，并保存到全局异常指针
    global_exception = std::current_exception();
  }
}

int main() {
  std::thread t(worker_thread);
  t.join();

  if (global_exception) {
    // 主线程检查是否有异常
    try {
      std::rethrow_exception(global_exception); // 重新抛出异常
    } catch (const std::exception& e) {
      std::cerr << "Caught exception in main thread: " << e.what() << std::endl;
    } catch (...) {
      std::cerr << "Caught unknown exception in main thread." << std::endl;
    }
  } else {
    std::cout << "Worker thread completed successfully." << std::endl;
  }

  return 0;
}

这个例子做了什么？

worker_thread()： 模拟一个工作线程，它可能会抛出一个 std::runtime_error 异常。
std::current_exception()： 这个函数是关键。它捕获当前线程正在处理的异常，并返回一个 std::exception_ptr 指针，指向该异常的拷贝。
global_exception： 我们用一个全局变量来存储这个异常指针，方便主线程访问。当然，实际项目中，你可能更倾向于使用更安全的方式，比如线程安全队列。
main()： 主线程等待工作线程结束后，检查 global_exception 是否为空。如果不为空，说明工作线程抛出了异常。
std::rethrow_exception()： 这个函数接收一个 std::exception_ptr 指针，并重新抛出它指向的异常。这样，主线程就可以像处理本地异常一样处理这个跨线程来的异常了。

核心函数详解

std::current_exception(): 这个函数返回一个 std::exception_ptr，指向当前正在处理的异常的拷贝。如果当前没有异常处理程序在运行，它会返回一个空的 std::exception_ptr。
std::rethrow_exception(std::exception_ptr p): 这个函数接收一个 std::exception_ptr，并重新抛出它指向的异常。如果 p 是一个空的 std::exception_ptr，它会抛出一个 std::bad_exception 异常。

进阶用法：避免全局变量

上面的例子为了简单，使用了全局变量来传递异常指针。在实际项目中，这可不是一个好主意。全局变量容易引起各种问题，比如线程安全问题，命名冲突等等。

咱们来改进一下，使用线程安全的队列来传递异常指针：

#include <iostream>
#include <thread>
#include <exception>
#include <stdexcept>
#include <queue>
#include <mutex>
#include <condition_variable>

// 线程安全队列
template <typename T>
class ThreadSafeQueue {
public:
  void push(T value) {
    std::lock_guard<std::mutex> lock(mutex_);
    queue_.push(std::move(value));
    condition_.notify_one();
  }

  std::optional<T> pop() {
    std::unique_lock<std::mutex> lock(mutex_);
    condition_.wait(lock, [this] { return !queue_.empty(); });
    T value = std::move(queue_.front());
    queue_.pop();
    return value;
  }

private:
  std::queue<T> queue_;
  std::mutex mutex_;
  std::condition_variable condition_;
};

ThreadSafeQueue<std::exception_ptr> exception_queue;

void worker_thread() {
  try {
    // 模拟一个可能抛出异常的操作
    throw std::runtime_error("Oops! Something went wrong in the worker thread.");
  } catch (...) {
    // 捕获异常，并保存到队列
    exception_queue.push(std::current_exception());
  }
}

int main() {
  std::thread t(worker_thread);
  t.join();

  if (auto exception_ptr = exception_queue.pop()) {
    // 主线程检查是否有异常
    try {
      std::rethrow_exception(*exception_ptr); // 重新抛出异常
    } catch (const std::exception& e) {
      std::cerr << "Caught exception in main thread: " << e.what() << std::endl;
    } catch (...) {
      std::cerr << "Caught unknown exception in main thread." << std::endl;
    }
  } else {
    std::cout << "Worker thread completed successfully." << std::endl;
  }

  return 0;
}

这个例子里，我们用了一个 ThreadSafeQueue 类来存储异常指针。这个队列是线程安全的，可以保证多个线程同时访问时的正确性。

std::exception_ptr 的限制

虽然 std::exception_ptr 很强大，但它也有一些限制：

拷贝语义： std::exception_ptr 存储的是异常的拷贝，而不是原始异常的引用。这意味着，如果你在另一个线程里修改了异常对象，原始异常对象不会受到影响。
性能开销： 拷贝异常对象会带来一定的性能开销。对于复杂的异常类型，拷贝的开销可能会比较大。
类型擦除： std::exception_ptr 实际上是类型擦除的，它只能告诉你“这里有一个异常”，但不能告诉你异常的具体类型。你需要使用 std::rethrow_exception 重新抛出异常，才能在 catch 块里根据异常类型进行处理。

std::exception_ptr 的应用场景

除了跨线程传递异常，std::exception_ptr 还有一些其他的应用场景：

异步编程： 在异步编程中，你可以使用 std::exception_ptr 来存储异步操作中抛出的异常，然后在稍后的某个时刻再处理这些异常。
错误日志记录： 你可以使用 std::exception_ptr 来捕获异常信息，并将其记录到错误日志中，方便后续的调试和分析。
回调函数： 在回调函数中，你可以使用 std::exception_ptr 来传递回调函数执行过程中抛出的异常。

std::exception_ptr vs. 其他异常处理方式

你可能会问，除了 std::exception_ptr，还有其他的异常处理方式吗？当然有！

直接传递异常对象： 你可以直接把异常对象传递给另一个线程。但这需要你确保异常对象是可拷贝的，并且不会在传递过程中被销毁。这种方式比较复杂，容易出错。
使用错误码： 你可以不使用异常，而是使用错误码来表示函数执行的结果。这种方式比较安全，但代码会变得比较冗长，可读性也会下降。

那么，std::exception_ptr 相比于这些方式有什么优势呢？

特性	`std::exception_ptr`	直接传递异常对象	使用错误码
线程安全	是	否	是
类型安全	否 (类型擦除)	是	是
异常信息	完整异常信息	完整异常信息	有限错误码
代码简洁程度	中等	复杂	冗长
性能开销	中等	可能较高	低

总的来说，std::exception_ptr 是一种比较平衡的方案，它既能保证线程安全，又能传递完整的异常信息，而且代码也比较简洁。

最佳实践

尽可能早地捕获异常： 不要等到异常传播到最顶层才去捕获它。尽早捕获异常，可以让你更好地了解异常发生的原因，并采取相应的措施。
使用线程安全的数据结构来传递异常指针： 不要使用全局变量来传递异常指针。使用线程安全的队列或其他数据结构，可以保证多个线程同时访问时的正确性。
在 catch 块里重新抛出异常： 不要在 catch 块里忽略异常。如果你不想处理这个异常，可以使用 throw; 重新抛出它，让上层调用者来处理。
注意异常的生命周期： std::exception_ptr 存储的是异常的拷贝，而不是原始异常的引用。你需要确保异常对象在拷贝之前不会被销毁。
考虑性能开销： 拷贝异常对象会带来一定的性能开销。对于复杂的异常类型，拷贝的开销可能会比较大。如果性能是关键，可以考虑使用其他的异常处理方式。

总结

std::exception_ptr 是 C++ 中一个非常有用的工具，它可以让你在不同的线程之间传递异常信息。虽然它有一些限制，但只要你了解它的工作原理，并遵循一些最佳实践，就可以用它来构建更加健壮和可靠的多线程程序。

好了，今天的讲座就到这里。希望大家对 std::exception_ptr 有了更深入的了解。如果大家还有什么问题，欢迎提问！

发表回复 取消回复

发表回复取消回复