std::thread抛异常时std::set_terminate+libunwind回溯异常问题

我在应用中使用std::set_terminate添加终止处理器用于调试，遇到了无法解释的行为：

• 主线程的构造函数（或同线程运行的成员函数）中抛出异常时，通过libunwind获取的调用栈回溯符合预期，能看到抛出异常的位置；
• 通过std::thread创建线程并在其中抛出异常时，调用栈仅显示execute_native_thread_routine，无法看到抛出点；
• 通过pthread_create创建线程则行为正常；
• 在std::thread中显式调用std::terminate时，能在栈中看到该调用，说明异常触发的terminate是从其他位置被调用的。

但我在独立测试程序中复现该场景时，所有情况均正常，不知该如何排查。以下是我的测试代码：

#define UNW_LOCAL_ONLY
#include <cxxabi.h>
#include <iomanip>
#include <iostream>
#include <libunwind.h>
#include <memory>
#include <stdlib.h>
#include <thread>
#include <unistd.h>

char const *get_demangled_name(char const *symbol) noexcept {
  if (!symbol) {
    return "<null>";
  }
  int status = -4;
  static std::unique_ptr<char, decltype(std::free) &> demangled_name{nullptr,
                                                                     std::free};
  demangled_name.reset(::abi::__cxa_demangle(symbol, demangled_name.release(),
                                             nullptr, &status));
  return ((status == 0) ? demangled_name.get() : symbol);
}

// 栈回溯实现
void backtrace() {
  unw_cursor_t cursor;
  unw_context_t context;

  // 初始化游标到当前帧，用于本地回溯
  unw_getcontext(&context);
  unw_init_local(&cursor, &context);

  // 逐个展开栈帧
  while (unw_step(&cursor) > 0) {
    unw_word_t offset, pc;
    unw_get_reg(&cursor, UNW_REG_IP, &pc);
    if (pc == 0) {
      break;
    }
    std::cout << pc << " : ";

    char sym[256];
    if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
      std::cout << sym << " + " << offset << "\n   " << get_demangled_name(sym) << std::endl;
    } else {
      std::cout << " -- error: unable to obtain symbol name for this frame" << std::endl;
    }
  }
}

void backtrace_on_terminate() noexcept {
  backtrace();
  std::abort(); // 或其他合适操作
}

class C {
public:
  void thread_func_member() {
    sleep(1);
    throw std::bad_alloc();
  }
};

int main(int argc, char *argv[]) {
  std::set_terminate(backtrace_on_terminate);

  C c;
  std::thread thr = std::thread(&C::thread_func_member, &c);
  sleep(3);
}

排查建议 #

1. 验证terminate_handler的线程继承性
   部分C++标准库实现中，std::thread创建的新线程不会自动继承主线程设置的terminate_handler。可以在std::thread的入口函数开头显式调用std::set_terminate(backtrace_on_terminate)，确认终止处理器是否在子线程中生效。

2. 检查std::thread的生命周期与异常触发时机
   当std::thread对象析构时，如果线程未被join或detach，标准库会自动调用std::terminate。此时线程函数的异常已经触发栈展开，原来的抛出点栈帧已被销毁，自然无法回溯到。
   验证方法：在主线程中调用thr.join()等待线程结束，对比调用栈变化；或者在线程函数中捕获异常后显式调用std::terminate，查看是否能看到抛出点。

3. 对比编译选项差异
   应用程序与测试程序的编译选项可能存在差异，比如：

   • 是否开启了-fomit-frame-pointer（会破坏栈回溯的帧指针链）；
   • 优化等级是否过高（-O2/-O3可能会优化掉栈帧信息）；
   • 是否添加了-g调试符号；
     确保两者使用完全一致的编译选项再测试。

4. 检查标准库实现差异
   不同的C标准库（如GCC的libstdc、Clang的libc++）对std::thread的异常处理逻辑可能不同。确认应用和测试程序链接的标准库版本、类型是否一致。

5. 栈展开对回溯的影响
   未捕获异常触发std::terminate时，标准允许实现先完成栈展开再调用终止处理器；而显式调用std::terminate不会触发栈展开。std::thread的异常处理流程可能触发了栈展开，导致抛出点的栈帧被销毁。可以尝试在应用中添加异常捕获，显式终止，对比栈回溯结果。

内容的提问来源于stack exchange，提问作者user3671607