C++带互斥锁对象的安全销毁：如何确保操作完成后再销毁？

要解决这个问题，核心是跟踪对象的活跃引用数，确保只有当所有正在进行的交互操作都完成、所有互斥锁都解锁后，对象才会被销毁。C++标准库提供了完美的内置解决方案：std::shared_ptr。

核心思路 #

std::shared_ptr通过原子化的引用计数机制管理对象生命周期：

• 每次创建shared_ptr拷贝时，引用计数原子加1；
• 每次shared_ptr销毁（或重置）时，引用计数原子减1；
• 当引用计数降至0时，自动调用对象的析构函数完成销毁。

这意味着，只要有任何交互操作持有对象的shared_ptr引用，对象就不会被销毁；只有当所有操作都完成、所有引用都释放后，对象才会被安全销毁，其内部的互斥锁也会随之正常析构。

具体实现步骤 #

1. 用std::shared_ptr管理目标对象
   将对象的所有权完全交给std::shared_ptr，所有创建、交互命令都通过shared_ptr访问对象，杜绝裸指针的使用。

2. 交互命令持有对象的shared_ptr拷贝
   所有修改、导出等交互命令执行前，先拷贝一份对象的shared_ptr到局部变量。这样即使全局的shared_ptr被重置（销毁命令触发），局部拷贝仍会维持引用计数，确保对象在操作完成前不会被销毁。

3. 销毁命令仅重置全局shared_ptr
   销毁命令不需要直接删除对象，只需重置全局的shared_ptr实例。此时若还有交互操作在运行，局部的shared_ptr拷贝会继续维持引用计数，对象会等到所有操作完成后自动销毁。

代码示例 #

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

// 目标对象类，内部包含互斥锁保护的数据
class ManagedObject {
public:
    void modifyData(const std::string& newData) {
        std::lock_guard<std::mutex> lock(dataMutex);
        data = newData;
        // 模拟耗时操作，验证销毁时机
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }

    std::string exportData() {
        std::lock_guard<std::mutex> lock(dataMutex);
        return data;
    }

    ~ManagedObject() {
        std::cout << "[日志] 对象已安全销毁" << std::endl;
    }

private:
    std::mutex dataMutex;
    std::string data = "初始值";
};

// 全局对象管理器，持有对象的shared_ptr
std::shared_ptr<ManagedObject> globalObject;

// 创建对象命令
void createCommand() {
    globalObject = std::make_shared<ManagedObject>();
    std::cout << "[日志] 对象已创建" << std::endl;
}

// 修改对象命令
void modifyCommand(const std::string& newData) {
    // 拷贝shared_ptr到局部，确保操作期间对象不会被销毁
    auto localObj = globalObject;
    if (!localObj) {
        std::cout << "[错误] 对象未创建" << std::endl;
        return;
    }
    std::cout << "[日志] 开始修改对象数据..." << std::endl;
    localObj->modifyData(newData);
    std::cout << "[日志] 对象数据修改完成" << std::endl;
}

// 导出对象命令
void exportCommand() {
    auto localObj = globalObject;
    if (!localObj) {
        std::cout << "[错误] 对象未创建" << std::endl;
        return;
    }
    std::cout << "[日志] 导出数据：" << localObj->exportData() << std::endl;
}

// 销毁对象命令
void destroyCommand() {
    if (!globalObject) {
        std::cout << "[错误] 对象未创建" << std::endl;
        return;
    }
    globalObject.reset();
    std::cout << "[日志] 已发起销毁请求，对象将在所有操作完成后销毁" << std::endl;
}

关键细节说明 #

• 线程安全：std::shared_ptr的引用计数操作是原子的，多线程环境下无需额外加锁，能正确处理并发的创建、交互、销毁命令。
• 互斥锁安全：对象内部的互斥锁是对象的成员变量，只有当对象被销毁时才会析构。由于shared_ptr的引用计数机制，对象销毁时所有交互操作已完成，互斥锁必然处于解锁状态（lock_guard会在作用域结束时自动解锁），不会出现互斥锁提前销毁的问题。
• 自定义销毁逻辑：如果对象需要额外的销毁操作（如释放外部资源），可在析构函数中实现，析构函数会自动在引用计数为0时触发。

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