如何在std::async异步任务抛异常时直接捕获而非等待stop()触发？

问题回顾 #

当前代码中，异步任务抛出的异常只能在调用stop()时通过future::get()捕获，无法即时响应并重建对象。需要实现异步任务异常抛出时立刻触发捕获、销毁原对象并重建的逻辑。

方案1：异步任务内部捕获异常，通过回调通知主线程 #

修改任务类的执行方法，内部捕获所有异常后，通过预先注册的回调函数通知主线程处理对象重建。异常一抛出就能被捕获并触发后续逻辑。

示例代码：

class ClassA
{
public:
    using ErrorCallback = std::function<void(ClassA*)>;

    void setErrorCallback(ErrorCallback cb) { m_error_cb = std::move(cb); }

    void running()
    {
        try {
            int count = 0;
            m_worker_stop.store(false); // 修正原代码错误：启动时应设为false
            while (!m_worker_stop.load())
            {
                count++;
                if (count == 10)
                {
                    std::vector v(100000000000); // 触发异常
                }            
            }
        }
        catch (...) {
            m_worker_stop.store(true);
            if (m_error_cb) {
                m_error_cb(this); // 通知主线程处理异常
            }
        }
    }

    void start()
    {
        m_worker = std::async(std::launch::async, &ClassA::running, this);
    }

    void stop()
    {
        m_worker_stop.store(true);
        if (m_worker.valid())
            m_worker.get();
    }

private:
    std::future<void> m_worker;
    std::atomic_bool m_worker_stop = { false };
    ErrorCallback m_error_cb;
};

class Main
{
public:
    void running()
    {
        createClassA();

        // 信号检测循环（保持原有逻辑）
        while (true) {
            // 处理SIGINT/SIGTERM等信号
            std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 避免空转
        }
    }

private:
    void createClassA()
    {
        m_classA = std::make_unique<ClassA>();
        // 注册异常回调
        m_classA->setErrorCallback([this](ClassA* obj) {
            if (obj == m_classA.get()) { // 确认是当前实例
                m_classA->stop();    // 确保任务安全结束
                m_classA.reset();    // 销毁原对象
                createClassA();      // 重建实例
            }
        });
        m_classA->start();
    }

    std::unique_ptr<ClassA> m_classA;
};

核心说明：

• 异步任务内部捕获异常，避免异常被std::future暂存
• 用std::unique_ptr管理对象生命周期，自动避免内存泄漏
• 回调逻辑中做实例校验，防止多实例场景下的误操作

方案2：主线程轮询检查任务状态 #

主线程在信号检测循环中，定期非阻塞检查异步任务的完成状态，一旦任务因异常结束，立刻触发捕获与重建逻辑。

示例代码：

// 修改ClassA，添加任务状态检查接口
class ClassA
{
public:
    bool isTaskFinished() const
    {
        return m_worker.valid() && 
               m_worker.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
    }

    // 其他方法同方案1（修正m_worker_stop初始值）
};

class Main
{
public:
    void running()
    {
        createClassA();

        while (true) {
            // 检查ClassA任务状态
            if (m_classA && m_classA->isTaskFinished()) {
                try {
                    m_classA->stop(); // 调用get()触发异常抛出
                }
                catch (...) {
                    m_classA.reset();
                    createClassA();
                }
            }

            // 信号检测逻辑
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }

private:
    void createClassA()
    {
        m_classA = std::make_unique<ClassA>();
        m_classA->start();
    }

    std::unique_ptr<ClassA> m_classA;
};

核心说明：

• 通过future::wait_for(0)实现非阻塞状态检查
• 适合对实时性要求不高的场景，可通过调整轮询间隔平衡性能与响应速度
• 逻辑简单，无需额外线程或队列

方案3：条件变量驱动的异常队列（高实时性） #

创建异常队列+条件变量，异步任务抛出异常时将异常信息存入队列并通知主线程，主线程异步处理队列中的异常事件，实时性更高。

示例代码：

// 异常队列（可作为Main类成员，避免全局变量）
struct TaskException
{
    void* task_ptr;
    std::exception_ptr exc_ptr;
};

std::queue<TaskException> g_exception_queue;
std::mutex g_queue_mutex;
std::condition_variable g_queue_cv;

class ClassA
{
public:
    void running()
    {
        try {
            int count = 0;
            m_worker_stop.store(false);
            while (!m_worker_stop.load())
            {
                count++;
                if (count == 10)
                {
                    std::vector v(100000000000);
                }            
            }
        }
        catch (...) {
            m_worker_stop.store(true);
            std::lock_guard<std::mutex> lock(g_queue_mutex);
            g_exception_queue.push({this, std::current_exception()});
            g_queue_cv.notify_one(); // 通知主线程处理
        }
    }

    // 其他方法同前
};

class Main
{
public:
    void running()
    {
        createClassA();

        // 启动异常处理线程
        std::thread exc_handler([this]() {
            while (true) {
                std::unique_lock<std::mutex> lock(g_queue_mutex);
                g_queue_cv.wait(lock, []{ return !g_exception_queue.empty(); });

                auto exc = g_exception_queue.front();
                g_exception_queue.pop();
                lock.unlock();

                // 处理ClassA的异常
                if (exc.task_ptr == m_classA.get()) {
                    m_classA->stop();
                    m_classA.reset();
                    createClassA();
                }
                // 可扩展处理ClassB/C/D的异常
            }
        });
        exc_handler.detach();

        // 信号检测循环
        while (true) {
            // 信号处理逻辑
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }

private:
    void createClassA()
    {
        m_classA = std::make_unique<ClassA>();
        m_classA->start();
    }

    std::unique_ptr<ClassA> m_classA;
};

核心说明：

• 用条件变量实现异步通知，主线程无需轮询，实时性拉满
• 通过std::exception_ptr完整保留异常信息，可按需重新抛出
• 适合多任务场景，可轻松扩展支持ClassB/C/D的异常处理

通用注意事项 #

1. 修正原代码错误：running()开头的m_worker_stop.store(true)会导致循环直接退出，启动时应设为false
2. 对象重建前必须调用stop()，确保异步任务完全终止，避免资源泄漏
3. 多线程场景下要严格保证线程安全，尤其是对象指针访问、队列操作等环节
4. 对于ClassB/C/D等同类对象，可抽象基类封装通用逻辑，减少代码重复

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