堆上std::function转为void*异步执行，在其内部释放内存是否安全？

核心结论 #

这种做法在修正关键问题后是安全的，但原生示例存在致命的悬垂引用风险，直接运行会触发未定义行为。

关键风险点与修正方案 #

1. 悬垂引用问题（最致命） #

示例中lambda使用[&t, data]引用捕获局部指针t，但t是fun函数的局部变量，fun执行完毕返回后，t的内存会被销毁，此时lambda内的引用就变成了悬垂引用——后续异步执行lambda时，访问这个引用会导致崩溃、内存乱码等不可预知的问题。

修正方案：将引用捕获改为值捕获[t, data]，让lambda保存指针的副本，这样即使fun返回，指针副本依然有效（只要堆上的std::function对象未被提前释放）。

2. 重复释放风险 #

必须严格保证：

• ExecuteAsync不会多次调用该std::function对象
• 没有其他代码路径会delete这个堆上的std::function对象

一旦出现双重释放，会直接导致程序崩溃或内存损坏。

3. 异常安全问题 #

如果lambda中//do something的代码抛出异常，delete t语句将不会执行，造成内存泄漏。

修正方案：用try/catch块包裹业务逻辑，确保delete一定会执行：

try {
    // do something（可能抛出异常的代码）
} catch (...) {
    // 可选：添加异常日志或处理逻辑
    throw; // 也可根据业务需求选择吞掉异常
}
delete t;

修正后的示例代码 #

using T = std::function<void()>;

void fun(int data)
{
    T* t = new T([t, data]()
    {
        try {
            // do something
        } catch (...) {
            // 异常处理逻辑
            throw;
        }
        delete t;
    });

    ExecuteAsync(reinterpret_cast<void*>(t)); // 转为void*传递给异步执行函数
}

更优替代方案 #

手动管理堆内存容易出错，推荐用智能指针消除手动delete的风险：
用std::unique_ptr包装std::function，转void*时释放所有权，异步执行时再转回智能指针，执行完毕后自动释放内存：

using T = std::function<void()>;

void ExecuteAsyncWrapper(void* ptr) {
    std::unique_ptr<T> func(static_cast<T*>(ptr));
    (*func)(); // 执行完毕后unique_ptr自动释放内存
}

void fun(int data)
{
    std::unique_ptr<T> t = std::make_unique<T>([data]()
    {
        // do something
    });

    ExecuteAsync(reinterpret_cast<void*>(t.release())); // 释放所有权给异步函数
}

这种方式从根源上避免了内存泄漏和双重释放的问题。

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