C++ 线程异常处理：跨线程异常的传播与 `std::exception_ptr`

好，我们开始今天的讲座！

各位观众老爷，今天我们要聊聊C++线程里那些让人头大的异常处理问题，特别是关于跨线程异常的传播，以及 std::exception_ptr 这个神奇的小东西。准备好了吗？系好安全带，咱们发车！

开场白：异常这玩意儿，哪里都有你！

在单线程的世界里，异常就像你家楼下的熊孩子，虽然烦人，但你总能找到机会收拾他。直接 try...catch 一把梭，问题解决！但到了多线程的世界，熊孩子学会了分身术，异常处理也跟着变得复杂起来。一个线程抛出的异常，如果没被及时抓住，很可能会导致程序直接崩溃，或者更糟糕，悄无声息地埋下隐患。

所以，掌握好C++线程的异常处理，尤其是在线程之间传递异常的能力，对于编写健壮、可靠的并发程序至关重要。

第一幕：线程异常的“原罪”

让我们先来回顾一下C++线程的一些基本概念，以及为什么线程异常的处理如此特殊。

• 线程的独立性： 每个线程都有自己的调用栈、程序计数器等，它们就像一个个独立的小王国，互不干扰（至少表面上是这样）。
• 异常的传播范围： 在单线程中，异常会沿着调用栈向上抛，直到被 catch 语句捕获。但在多线程环境中，这个传播范围仅限于当前线程。一个线程抛出的异常，除非你刻意安排，否则不会自动传播到其他线程。

这意味着什么？意味着如果你在一个线程里抛出了一个异常，而这个线程又没有 try...catch 来处理它，那么这个线程会直接崩溃，但主线程（或者其他线程）可能对此一无所知！这就像你隔壁邻居家着火了，你却还在家里葛优躺，想想都觉得可怕。

第二幕：std::exception_ptr：异常的快递员

为了解决跨线程异常传播的问题，C++11引入了 std::exception_ptr 这个概念。它可以被看作是一个指向异常对象的智能指针，但它并不拥有异常对象的所有权。它的主要作用是：

• 保存异常： 它可以捕获一个异常，并将其存储起来。
• 传递异常： 它可以将存储的异常传递给其他线程。
• 重新抛出异常： 接收到异常的线程可以使用 std::rethrow_exception 函数将异常重新抛出。

简单来说，std::exception_ptr 就像一个快递员，负责把一个线程抛出的异常，安全地送到另一个线程手中。

第三幕：实战演练：std::exception_ptr 的用法

光说不练假把式，让我们通过几个例子来看看 std::exception_ptr 在实际开发中的应用。

场景一：异步任务中的异常处理

假设我们需要异步执行一个耗时的任务，如果任务执行过程中抛出了异常，我们希望能够在主线程中捕获并处理这个异常。

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

std::exception_ptr task() {
  try {
    // 模拟耗时任务
    std::cout << "Task started..." << std::endl;
    // 模拟抛出异常
    throw std::runtime_error("Something went wrong in the task!");
    std::cout << "Task finished..." << std::endl; // 这行代码不会被执行
  } catch (...) {
    // 捕获异常，并将其存储到 std::exception_ptr 中
    return std::current_exception();
  }
  return nullptr; // 如果没有异常，返回 nullptr
}

int main() {
  // 启动一个异步任务
  std::future<std::exception_ptr> future = std::async(std::launch::async, task);

  // 在主线程中等待任务完成，并获取异常
  std::exception_ptr eptr = future.get();

  // 检查是否有异常
  if (eptr) {
    try {
      // 重新抛出异常
      std::rethrow_exception(eptr);
    } catch (const std::exception& e) {
      // 处理异常
      std::cerr << "Caught exception in main: " << e.what() << std::endl;
    } catch (...) {
      // 处理未知异常
      std::cerr << "Caught unknown exception in main." << std::endl;
    }
  } else {
    std::cout << "Task completed successfully." << std::endl;
  }

  return 0;
}

在这个例子中，task 函数模拟了一个异步任务，它可能会抛出一个 std::runtime_error 异常。我们使用 std::current_exception() 函数捕获了这个异常，并将其存储到 std::exception_ptr 中。然后，我们将这个 std::exception_ptr 返回给主线程。

在主线程中，我们通过 future.get() 获取 std::exception_ptr，并检查它是否为空。如果它不为空，说明任务执行过程中抛出了异常，我们使用 std::rethrow_exception 函数将异常重新抛出，并在主线程中捕获并处理它。

场景二：线程池中的异常处理

线程池是一种常用的并发编程模式，它可以有效地管理和复用线程。在线程池中，如果一个任务抛出了异常，我们希望能够将这个异常传递给调用者，以便进行统一的错误处理。

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

class ThreadPool {
public:
  ThreadPool(size_t numThreads) : stop(false) {
    threads.reserve(numThreads);
    for (size_t i = 0; i < numThreads; ++i) {
      threads.emplace_back([this] {
        while (true) {
          std::function<void()> task;

          {
            std::unique_lock<std::mutex> lock(queueMutex);
            condition.wait(lock, [this] { return stop || !tasks.empty(); });

            if (stop && tasks.empty()) {
              return;
            }

            task = std::move(tasks.front());
            tasks.pop();
          }

          try {
            task();
          } catch (...) {
            std::exception_ptr eptr = std::current_exception();
            {
              std::lock_guard<std::mutex> lock(exceptionMutex);
              exceptions.push(eptr);
            }
            exceptionCondition.notify_one();
          }
        }
      });
    }
  }

  template <typename F, typename... Args>
  std::future<typename std::result_of<F(Args...)>::type> enqueue(F&& f, Args&&... args) {
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared<std::packaged_task<return_type()>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );

    std::future<return_type> res = task->get_future();
    {
      std::unique_lock<std::mutex> lock(queueMutex);
      tasks.emplace([task]() { (*task)(); });
    }
    condition.notify_one();
    return res;
  }

  ~ThreadPool() {
    {
      std::unique_lock<std::mutex> lock(queueMutex);
      stop = true;
    }
    condition.notify_all();
    for (std::thread& thread : threads) {
      thread.join();
    }

    // 清理异常队列，重新抛出异常
    while (!exceptions.empty()) {
      try {
        std::rethrow_exception(exceptions.front());
      } catch (const std::exception& e) {
        std::cerr << "Caught exception in thread pool: " << e.what() << std::endl;
      } catch (...) {
        std::cerr << "Caught unknown exception in thread pool." << std::endl;
      }
      exceptions.pop();
    }
  }

private:
  std::vector<std::thread> threads;
  std::queue<std::function<void()>> tasks;
  std::mutex queueMutex;
  std::condition_variable condition;
  bool stop;

  // 异常处理相关
  std::queue<std::exception_ptr> exceptions;
  std::mutex exceptionMutex;
  std::condition_variable exceptionCondition;
};

int main() {
  ThreadPool pool(4);

  // 提交一个会抛出异常的任务
  auto future = pool.enqueue([]() -> int {
    std::cout << "Task in thread pool started..." << std::endl;
    throw std::runtime_error("Exception from thread pool task!");
    return 42;
  });

  try {
    future.get(); // 获取任务结果，如果任务抛出异常，这里会重新抛出异常
  } catch (const std::exception& e) {
    std::cerr << "Caught exception in main: " << e.what() << std::endl;
  } catch (...) {
    std::cerr << "Caught unknown exception in main." << std::endl;
  }

  return 0;
}

在这个例子中，我们创建了一个简单的线程池 ThreadPool。每个线程都会不断地从任务队列中取出任务并执行。如果任务执行过程中抛出了异常，我们会使用 std::current_exception() 函数捕获这个异常，并将其存储到 exceptions 队列中。

在 ThreadPool 的析构函数中，我们会遍历 exceptions 队列，并将队列中的异常重新抛出。这样，调用者就可以在主线程中捕获并处理这些异常。

第四幕：std::nested_exception：异常的俄罗斯套娃

C++11还引入了 std::nested_exception，它可以用来包装一个已存在的异常，并将其作为新异常的一部分抛出。这就像俄罗斯套娃，一个套一个，异常里面套异常。

std::nested_exception 通常与 std::exception_ptr 一起使用，以便在捕获异常时，能够访问到原始异常的信息。

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

class MyException : public std::exception, public std::nested_exception {
public:
  MyException(const std::string& msg) : message(msg) {}
  const char* what() const noexcept override { return message.c_str(); }

private:
  std::string message;
};

void foo() {
  try {
    // 模拟一些可能抛出异常的代码
    throw std::runtime_error("Error in foo()");
  } catch (...) {
    // 捕获异常，并将其嵌套到 MyException 中
    throw MyException("MyException wrapping foo's exception");
  }
}

int main() {
  try {
    foo();
  } catch (const MyException& e) {
    std::cerr << "Caught MyException: " << e.what() << std::endl;

    // 访问嵌套的异常
    try {
      std::rethrow_if_nested(e);
    } catch (const std::exception& nested) {
      std::cerr << "Nested exception: " << nested.what() << std::endl;
    } catch (...) {
      std::cerr << "Nested exception is not std::exception" << std::endl;
    }
  } catch (const std::exception& e) {
    std::cerr << "Caught exception: " << e.what() << std::endl;
  } catch (...) {
    std::cerr << "Caught unknown exception" << std::endl;
  }

  return 0;
}

在这个例子中，foo 函数可能会抛出一个 std::runtime_error 异常。我们捕获这个异常，并将其嵌套到 MyException 中。在 main 函数中，我们捕获 MyException，并使用 std::rethrow_if_nested 函数来访问嵌套的异常。

第五幕：线程异常处理的最佳实践

最后，让我们来总结一下C++线程异常处理的一些最佳实践：

• 尽早捕获异常： 尽量在异常抛出的线程中捕获并处理异常。避免让异常传播到其他线程，导致程序崩溃。
• 使用 std::exception_ptr 传递异常： 如果需要在线程之间传递异常，使用 std::exception_ptr 是一个安全可靠的选择。
• 考虑使用线程池： 线程池可以有效地管理和复用线程，并提供统一的异常处理机制。
• 使用 RAII 管理资源： RAII (Resource Acquisition Is Initialization) 是一种常用的资源管理技术，它可以确保在异常抛出时，资源能够被正确释放。
• 编写单元测试： 编写单元测试可以帮助你发现和修复线程相关的异常处理问题。

表格总结：

| 技术/概念 | 描述 | 适用场景 | 注意事项 and so on…

• 使用 std::future 获取返回值： 如果需要在线程之间传递返回值，可以使用 std::future。

结束语：

C++线程的异常处理是一个复杂的问题，但只要我们掌握了正确的方法，就可以编写出更加健壮、可靠的并发程序。希望今天的讲座能够帮助大家更好地理解和应用C++线程的异常处理机制。

记住，异常处理就像安全气囊，平时用不上，但关键时刻能救命！

感谢各位的观看，下次再见！