c++ - C++ 中的(共享)互斥体

Question

我看到了共享互斥锁的示例:

class MyData {
    std::vector<double> data_;
    mutable shared_mutex mut_;   // the mutex to protect data_;

public:
    void write() {
        unique_lock<shared_mutex> lk(mut_);
        // ... write to data_ ...
    }

    void read() const {
        shared_lock<shared_mutex> lk(mut_);
        // ... read the data ...
    }
};

我自然会写成:

public:
    void write() {
        mut_.lock();
        // ... write to data_ ...
        mut_.unlock();
    }

    void read() const {
        mut_.lock_shared();
        // ... read the data ...
        mut_.unlock_shared();
    }
};

我的方法也正确吗？我使用的和示例中使用的有区别吗？另外，其中一种比另一种有优势吗？谢谢!

Answer 1

Is my way also correct?

考虑如果互斥锁锁定和解锁之间的代码抛出异常会发生什么:

void write() {
    mut_.lock();
    // <-- exception is thrown here
    mut_.unlock();
}

互斥体随后保持锁定状态。

are there advantages of one over the other?

是的， unique_lock<> 跟在 RAII idiom 后面，因此在出现异常时会自动处理互斥体的解锁(即通过其析构函数):

void write() {
    unique_lock<shared_mutex> lk(mut_);
    // <-- exception is thrown
}

如果在创建 unique_lock<shared_mutex> 对象后发生异常 - lk - 它的析构函数被调用，然后它会解锁关联的互斥锁(如果它被锁定)(请记住， std::unique_lock 与 std::lock_guard 不同，并不总是拥有该对象的所有权)锁定关联的互斥锁 - 请参阅 std::defer_lock 和 std::unique_lock::unlock() )。

总而言之，使用 lock_guard/unique_lock/shared_lock ，在出现异常或从不同执行路径离开成员函数时，您不需要进行特殊处理。