C++多成员函数共享实例的跨调用线程安全锁定方案咨询

现有方案的可行性 #

你当前直接在release里调用mtx.unlock()的写法，在业务逻辑100%严格遵循「先reserve、后release，且二者一一配对」的前提下是可以正常运行的，但存在多个严重的安全隐患，生产环境不建议直接使用：

• 异常不安全：如果reserve之后、release之前的代码抛出异常，release就永远不会被调用，mutex会被永久锁死，所有其他线程都无法获取资源
• 未定义行为风险：一旦出现「未调用reserve就调用release」「重复调用release」的误用，直接调用unlock属于C++标准定义的未定义行为，会导致程序崩溃或者逻辑混乱
• 成员函数无安全校验：你当前的incrementIt/decrementIt等成员函数没有校验调用者身份，未持有锁的线程也可以直接调用这些函数修改数据，依然会产生数据竞争

如何保证unlock时mutex一定处于锁定状态 #

可以通过状态追踪+RAII封装的方式彻底解决这个问题，同时不需要你手动管理锁的释放，也避免你担心的lock_guard只能在单个函数作用域生效的问题：

1. 新增状态字段追踪锁的持有情况：在struct内部新增锁的持有线程id、加锁状态两个字段，加锁时记录状态，解锁时先校验状态是否合法，只有持有锁的线程才能执行解锁
2. 用RAII类封装锁的生命周期：你觉得std::lock_guard只能在单个函数生效，本质是因为你把它的生命周期绑定到了函数栈帧，你完全可以自己封装一个资源持有Guard，将它的生命周期和你需要持有锁的周期绑定，什么时候要释放锁就什么时候销毁Guard对象即可，完全不需要手动调用release，天然避免异常安全问题

优化后的实现代码 #

#include <iostream>
#include <thread>
#include <mutex>
#include <stdexcept>

struct information_t {
private:
    std::mutex mtx;
    int importantValue = 0;
    std::thread::id owner_thread;
    bool is_locked = false;

    // 内部校验当前线程是否持有锁
    void check_owner() const {
        if (!is_locked || std::this_thread::get_id() != owner_thread) {
            throw std::runtime_error("Current thread does not hold the resource lock");
        }
    }

public:
    // 预留资源，返回RAII Guard，只要Guard不销毁资源就一直被当前线程持有
    class ReserveGuard {
    private:
        information_t& res;
        explicit ReserveGuard(information_t& resource) : res(resource) {
            res.mtx.lock();
            res.is_locked = true;
            res.owner_thread = std::this_thread::get_id();
        }
        friend struct information_t;
    public:
        // 禁止拷贝
        ReserveGuard(const ReserveGuard&) = delete;
        ReserveGuard& operator=(const ReserveGuard&) = delete;
        // 移动语义支持把Guard传到其他作用域持有
        ReserveGuard(ReserveGuard&&) = default;
        ReserveGuard& operator=(ReserveGuard&&) = default;

        ~ReserveGuard() {
            res.is_locked = false;
            res.mtx.unlock();
        }
    };

    ReserveGuard reserve() {
        return ReserveGuard(*this);
    }

    // 所有操作接口都先校验调用者权限
    void incrementIt() {
        check_owner();
        importantValue++;
    }
    void decrementIt() {
        check_owner();
        importantValue--;
    }
    void reset() {
        check_owner();
        importantValue = 0;
    }
    int getValue() const {
        check_owner();
        return importantValue;
    }

} protectedResource;

int main()
{
    std::thread threads[3];
    
    threads[0] = std::thread([]
    {
        auto guard = protectedResource.reserve();
        protectedResource.incrementIt();
        protectedResource.incrementIt();
        std::cout << "Thread 0 Result: " << protectedResource.getValue() << '\n';
        // guard销毁时自动释放资源，无需手动调用release
    });

    threads[1] = std::thread([]
        {
            auto guard = protectedResource.reserve();
            std::cout << "Thread 1 Result: " << protectedResource.getValue() << '\n';
        });

    threads[2] = std::thread([]
        {
            auto guard = protectedResource.reserve();
            protectedResource.decrementIt();
            std::cout << "Thread 2 Result: " << protectedResource.getValue() << '\n';
        });

    for (auto& th : threads) th.join();

    return 0;
}

这个实现的优势：

• 完全不需要手动调用release，只要Guard对象存在，锁就一直被持有，你可以把Guard移动到任意你需要的作用域存放，突破单个函数的生命周期限制
• 解锁前会自动校验状态，不可能出现未锁就解锁、重复解锁的问题
• 所有成员函数都有权限校验，未持有锁的线程无法修改数据，彻底避免数据竞争
• 天然异常安全，哪怕持有锁期间代码抛出异常，Guard会被自动析构，锁会正常释放

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