捕获线程异常后无法触发程序退出，求正确实现方法

嘿，我来帮你分析下问题所在——你的代码里有两个核心问题导致程序执行不到exit()语句：

问题1：主线程的try/catch块完全没起到作用 #

你把workerThread.run()放进了try块，但run()函数只是启动线程然后调用detach()，这个过程根本不会抛出任何异常。工作线程里的异常是在独立的执行流中抛出的，主线程的这个try/catch完全捕获不到它。

问题2：主线程从未检查异常指针的状态 #

你在工作线程里把异常存到了_exceptionPtr里，但主线程一直在自己的死循环里执行do A/B/C，完全没去查看这个指针是否已经被设置。所以即使10秒后工作线程抛出了异常，主线程也完全不知道这件事。

当前方案的其他潜在问题 #

• 使用全局的_exceptionPtr不够优雅，而且严格来说，多线程下对非原子变量的读写存在数据竞争风险（虽然std::exception_ptr的赋值操作是线程安全的，但全局变量的设计依然破坏了封装性）。
• 调用thread.detach()后，你失去了对工作线程的控制权，无法追踪它的运行状态。

修正后的实现方案 #

我们需要让主线程定期检查异常状态，同时把异常指针封装到WorkerThread类里，用原子类型保证线程安全：

#include <thread>
#include <iostream>
#include <stdexcept>
#include <atomic>

struct WorkerThread
{
    std::thread thread;
    std::atomic<std::exception_ptr> exceptionPtr = nullptr; // 原子变量保证线程安全

    void doSomething()
    {
        int seconds = 0;
        bool shouldStop = false;

        while(!shouldStop)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            std::cout << "time passed : " << ++seconds << " seconds" << std::endl;

            if (seconds == 10) // 模拟异常场景
            {
                try
                {
                    shouldStop = true;
                    throw std::runtime_error("something really bad happened");
                }
                catch (...)
                {
                    // 捕获所有异常并存入原子指针
                    exceptionPtr.store(std::current_exception());
                }
            }
        }
    }

    void run()
    {
        thread = std::thread([this] { doSomething(); });
        // 不要detach，保留线程句柄以便后续控制
        // thread.detach(); 
    }

    // 提供检查异常的接口
    bool hasException() const
    {
        return exceptionPtr.load() != nullptr;
    }

    // 重新抛出异常的接口
    void rethrowException()
    {
        auto ptr = exceptionPtr.load();
        if (ptr)
        {
            std::rethrow_exception(ptr);
        }
    }
};

int main(int argc, char *argv[])
{
    WorkerThread workerThread;
    workerThread.run();

    for (;;)
    {
        // 每次循环先检查是否有异常发生
        if (workerThread.hasException())
        {
            try
            {
                workerThread.rethrowException();
            }
            catch (const std::runtime_error &ex)
            {
                std::cout << "Caught exception: " << ex.what() << std::endl;
                std::cout << "Program will now exit" << std::endl;
                exit(EXIT_FAILURE);
            }
        }

        // 主线程的正常工作逻辑
        std::cout << "waiting for thread..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }

    // 若后续需要等待线程结束，可取消注释
    // workerThread.thread.join();
    return 0;
}

关键改进点 #

1. 主线程定期检查异常：在每次循环开始时检查工作线程的异常指针，一旦发现异常就处理并退出。
2. 原子异常指针：用std::atomic<std::exception_ptr>保证多线程下读写的线程安全，避免数据竞争。
3. 封装异常状态：把异常指针作为类成员，提供hasException()和rethrowException()接口，代码更整洁易维护。
4. 避免detach线程：保留线程句柄，后续如果需要控制线程生命周期会更灵活。

这样修改后，当工作线程在10秒后抛出异常，主线程会在下一次循环检查到异常指针，然后重新抛出并执行exit()语句，程序就能正常退出了。

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