异步回调导致的野指针，怎么加锁

异步回调导致的野指针问题通常发生在多线程编程中。当一个对象的生命周期结束，但某个回调函数仍然持有该对象的指针并在之后被调用，就会导致访问已经被销毁的内存，进而产生野指针问题。

为了避免这个问题，可以使用锁来控制对象的生命周期和回调的执行顺序。以下是一些常见的方法来加锁，防止异步回调导致的野指针问题：

1. 使用互斥锁（Mutex）

你可以在对象的生命周期管理中引入互斥锁，确保在回调函数执行时，对象不会被销毁。示例代码如下：

```cpp
#include <iostream>
#include <mutex>
#include <thread>
#include <functional>

class MyClass {
public:
    MyClass() : value(0) {}

    void doAsyncTask(std::function<void(int)> callback) {
        std::lock_guard<std::mutex> lock(mtx); // 加锁
        callbackFunction = callback;
        // 模拟异步任务
        std::thread([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::lock_guard<std::mutex> lock(mtx); // 回调时再加锁
            if (callbackFunction) {
                callbackFunction(value);
            }
        }).detach();
    }

    void setValue(int v) {
        std::lock_guard<std::mutex> lock(mtx); // 加锁
        value = v;
    }

    ~MyClass() {
        std::lock_guard<std::mutex> lock(mtx); // 在析构函数中加锁，避免回调访问已销毁的对象
        callbackFunction = nullptr;
    }

private:
    int value;
    std::function<void(int)> callbackFunction;
    std::mutex mtx;
};

int main() {
    MyClass* myObject = new MyClass();
    myObject->doAsyncTask([](int v) {
        std::cout << "Async task result: " << v << std::endl;
    });

    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟其他操作
    delete myObject; // 这里删除对象，如果没有加锁可能导致野指针
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待异步任务完成
    return 0;
}

## 2. 使用智能指针（如 std::shared_ptr）

使用 std::shared_ptr 来管理对象的生命周期，可以避免野指针问题。回调函数中使用智能指针，确保对象在回调期间不会被销毁：


```cpp
#include <iostream>
#include <memory>
#include <thread>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    void doAsyncTask() {
        auto self = shared_from_this();
        std::thread([self]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            self->callback();  // 通过智能指针调用回调，确保对象存在
        }).detach();
    }

    void callback() {
        std::cout << "Async task result" << std::endl;
    }
};

int main() {
    auto myObject = std::make_shared<MyClass>();
    myObject->doAsyncTask();

    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟其他操作
    // 此处不用显式删除对象，因为智能指针会自动管理生命周期
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待异步任务完成
    return 0;
}

3. 使用 std::weak_ptr

在某些场景下，如果不希望延长对象的生命周期，可以使用 std::weak_ptr。在回调中，将 std::weak_ptr 升级为 std::shared_ptr，如果成功，说明对象仍然存在；否则，对象已经被销毁：

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

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    void doAsyncTask() {
        std::weak_ptr<MyClass> self = shared_from_this();
        std::thread([self]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            if (auto ptr = self.lock()) {  // 尝试升级为shared_ptr
                ptr->callback();
            } else {
                std::cout << "Object has been deleted" << std::endl;
            }
        }).detach();
    }

    void callback() {
        std::cout << "Async task result" << std::endl;
    }
};

int main() {
    auto myObject = std::make_shared<MyClass>();
    myObject->doAsyncTask();

    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟其他操作
    // 此处不用显式删除对象，因为智能指针会自动管理生命周期
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待异步任务完成
    return 0;
}

总结

使用互斥锁可以确保在回调函数执行期间对象不会被销毁，但可能会增加锁的开销。
智能指针(std::shared_ptr 和 std::weak_ptr) 是管理对象生命周期的好工具，能有效避免野指针问题，推荐在异步回调场景中使用。
根据具体场景选择合适的方法，确保对象的生命周期和回调之间的同步控制。