局部对象超出作用域后，其异步成员函数会发生什么？正在运行的异步任务是否存在风险？

这个问题问到点子上了——这是C++异步编程里非常容易踩的坑，我来给你掰扯清楚：

当你写这样的代码时：

{
    Example example;
    example.asyncFuncInside();
}

代码块结束后，局部对象example会被立即析构，但如果它的asyncFuncInside()启动的异步任务还在后台运行，大概率会出现严重的未定义行为，具体风险分这几种：

核心风险点 #

• 悬空指针访问：如果异步函数内部通过this指针访问对象的成员变量（比如this->m_data）或者成员函数，对象销毁后this就变成了悬空指针。这时候再访问这些成员，可能直接导致程序崩溃，也可能读取到垃圾数据，甚至出现“看起来正常”但实际逻辑错乱的诡异情况——这类问题最难排查。
• 资源冲突：如果Example的析构函数会清理异步任务正在使用的资源（比如关闭文件句柄、释放动态分配的内存、断开网络连接），那么异步任务继续操作这些已被回收的资源，必然会触发错误，比如内存访问违规。
• 析构与异步任务的竞态：极端情况下，对象析构的过程和异步任务的执行可能同时进行，比如析构函数正在销毁某个成员，而异步任务刚好要读写这个成员，这会引发不可预测的竞态条件，程序行为完全失控。

当然也有例外：如果异步函数内部捕获了对象的拷贝（比如lambda里用*this而不是this，或者通过值传递获取了对象的副本），那对象销毁后拷贝还在，这时候异步任务是安全的。但这种情况需要你明确控制，不是默认行为。

靠谱的解决方案 #

针对这个问题，有几种常用的解决思路：

1. 用智能指针延长对象生命周期 #

让对象通过std::shared_ptr管理，异步任务捕获shared_from_this()的引用，这样只要异步任务还在运行，对象的引用计数就不会降到0，也就不会被析构。示例代码如下：

#include <memory>
#include <thread>
#include <chrono>
#include <iostream>

class Example : public std::enable_shared_from_this<Example> {
public:
    void asyncFuncInside() {
        // 捕获自身的shared_ptr，确保对象不会被提前销毁
        auto self = shared_from_this();
        std::thread([self]() {
            std::this_thread::sleep_for(std::chrono::seconds(2));
            std::cout << "Safe access: " << self->m_data << std::endl;
        }).detach();
    }
private:
    int m_data = 42;
};

int main() {
    {
        auto example = std::make_shared<Example>();
        example->asyncFuncInside();
    }
    // 这里主线程可以做其他事，异步任务结束后对象才会被销毁
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return 0;
}

2. 在析构时取消并等待异步任务 #

给类添加一个取消机制，比如用std::stop_source或者手动的标志位，在析构时通知异步任务停止，并等待任务执行完毕再销毁对象。示例：

#include <thread>
#include <chrono>
#include <iostream>
#include <stop_token>

class Example {
public:
    Example() : m_stopSource(std::stop_source{}) {}
    
    ~Example() {
        // 通知异步任务停止
        m_stopSource.request_stop();
        // 等待任务结束（如果线程是joinable的）
        if (m_asyncTask.joinable()) {
            m_asyncTask.join();
        }
    }

    void asyncFuncInside() {
        m_asyncTask = std::thread([token = m_stopSource.get_token(), this]() {
            while (!token.stop_requested()) {
                std::cout << "Running async task..." << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            std::cout << "Async task stopped." << std::endl;
        });
    }
private:
    std::thread m_asyncTask;
    std::stop_source m_stopSource;
};

int main() {
    {
        Example example;
        example.asyncFuncInside();
        std::this_thread::sleep_for(std::chrono::seconds(2));
    } // 析构时会等待异步任务停止
    return 0;
}

3. 让异步任务完全独立于对象 #

把异步任务需要的所有数据都拷贝到任务内部，让它不依赖对象的任何状态。比如在启动异步任务时，将成员变量的值传递进去，而不是通过this访问：

void Example::asyncFuncInside() {
    int localData = m_data; // 拷贝需要的数据
    std::thread([localData]() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        std::cout << "Independent access: " << localData << std::endl;
    }).detach();
}

这种方式最简单，但只适用于异步任务不需要修改对象状态、且数据可以轻松拷贝的场景。

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