c++：互斥体、守卫和函数调用

Question

我想知道。当我使用std::mutex _lock 并且想依靠守卫释放它时，我可以这样使用它吗？

class MyClass{
private:
    mutable std::mutex _lock;
    void subroutine(){/*...*/}
public:
    void foo(){
        std::lock(_lock);std::lock_guard<std::mutex> g(_lock, std::adopt_lock);
        subroutine();
        //require I still have the lock here
        //...
        return; //g goes out of scope ==> _lock is released
    }
};

或者对subroutine 的调用是否已经导致锁被释放？如果是后者，我的选择是什么？

更新

这个案子呢？

class MyClass{
private:
    mutable std::mutex _lock;
public:
    void subroutine(){ //can be called on its own
        std::lock(_lock);std::lock_guard<std::mutex> g(_lock, std::adopt_lock);
        /*...*/
    }
    void foo(){
        std::lock(_lock);std::lock_guard<std::mutex> g(_lock, std::adopt_lock);
        subroutine();
        //require I still have the lock here
        //...
        return; //g goes out of scope ==> _lock is released
    }
};

Answer 1

对子例程的调用不会导致锁被释放。 当 std::lock_guard 对象超出范围时（正如您在评论中提到的那样），线程对 _lock 的锁定被释放。

void foo(){
    std::lock_guard<std::mutex> lg{_lock}; // lock the mutex
    subroutine(); // lock is held here during this call
    // so subroutine must not attempt to lock the mutex _lock!
    return; // lg goes out of scope => its destructor is called which releases the lock on _lock
}

要回答您的第二个问题，当 foo 获取 _lock 上的锁然后调用子例程时，您会遇到问题，该子例程再次尝试锁定 _lock。线程无法获取已持有锁的互斥锁。我会重新考虑你的班级设计。如果你绝对必须有这个设计，你可以做类似的事情

void subroutine(bool called_from_foo = false)
{
    if(!called_from_foo)
        std::lock_guard<std::mutex> lg{_lock};
    /* ... */
}

void foo()
{
    std::lock_guard<std::mutex> lg{_lock};
    subroutine(true);
    /* ... */
    return;
}

虽然我不推荐这样做，因为它很容易以错误的方式使用子例程，导致程序中出现未定义的行为。

如果您发现自己必须在函数之间传递锁的所有者，我会看看 std::unique_lock，因为这种类型是可移动的。