避免线程捕获异常后detach时调用std::terminate()

你遇到的这个问题其实是C++线程模型里一个很容易踩的坑，我来帮你拆解清楚：

核心原因：线程对象的析构行为 #

你提到捕获异常后调用Sleep(INFINITE)让子线程暂停，这时候线程其实还处于**可join（joinable）**的状态。而C++标准明确规定：当std::thread对象的析构函数被调用时，如果该线程仍然是joinable的（既没有被join()等待结束，也没有被detach()分离），那么析构函数会直接调用std::terminate()终止程序——这和你线程内部有没有捕获异常完全无关！

这就是为什么你明明已经catch了异常，程序还是会触发std::terminate()的关键原因。

次要可能：异常未被完全处理（概率较低） #

如果上述情况不是你的问题，那就要检查你的catch(...)块逻辑：

• 是不是在捕获异常后，又不小心重新抛出了（比如写了throw;但没注意）？
• 保存异常的exc对象有没有在后续操作中触发新的异常？

不过结合你说的“调用Sleep(INFINITE)仍会触发”，第一种原因的可能性更大。

解决方案 #

针对线程对象析构的问题，你有两种常见的处理方式：

1. 显式等待线程结束（推荐） #

在主线程中，或者你的自定义线程类的合适位置，调用join()等待子线程完成。比如：

// 假设你的自定义线程类有一个get_thread()方法返回内部的std::thread引用
MyThread t(...);
// 执行其他逻辑...
t.get_thread().join(); // 等待子线程结束，此时线程对象不再joinable

如果你的自定义线程类封装了std::thread，最好在类的析构函数里判断是否joinable，如果是则调用join()，避免意外：

class MyThread {
private:
    std::thread inner_thread;
    std::exception_ptr exc;
public:
    // ...你的构造函数和其他方法...
    ~MyThread() {
        if (inner_thread.joinable()) {
            inner_thread.join(); // 等待线程结束
        }
    }
};

2. 分离线程（适合不需要等待的场景） #

如果你不需要主线程等待子线程结束，可以调用detach()将线程与对象分离，这样线程会在后台运行，线程对象析构时不会触发std::terminate()：

MyThread t(...);
t.get_thread().detach();

不过要注意，分离后的线程无法再被join()，而且如果主线程先退出，子线程可能会被强制终止，需要根据你的业务场景选择。

额外提示：异常保存的正确姿势 #

如果你想在线程外处理捕获的异常，需要用std::exception_ptr来保存，后续可以在主线程中重新抛出处理：

// 子线程内捕获并保存
catch (...) {
    exc = std::current_exception();
    // 这里可以正常返回，不需要Sleep(INFINITE)，让线程结束后主线程join再处理异常
}

// 主线程中处理
if (t.exc) {
    try {
        std::rethrow_exception(t.exc);
    } catch (const std::exception& e) {
        std::cout << "Caught exception from thread: " << e.what() << std::endl;
    } catch (...) {
        std::cout << "Caught unknown exception from thread" << std::endl;
    }
}

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