是否可以将std :: condition_variable与std :: lock_guard一起使用？

Question

我正在使用这样的std::condition_variable结合std::unique_lock。

std::mutex a_mutex;
std::condition_variable a_condition_variable;
std::unique_lock<std::mutex> a_lock(a_mutex);
a_condition_variable.wait(a_lock, [this] {return something;});
//Do something
a_lock.unlock();

工作正常。据我了解，std::condition_variable接受std::unique_lock它等待。但是，我正在尝试将其与std::lock_guard但不能结合在一起。

我的问题是： 可以std::unique_lock用a std::lock_guard代替吗？这样可以避免我每次使用锁时都手动解锁。

Answer 1

不可能，但你实际上并不需要它。

\n\n

std::unique_lock如果被锁定，会在析构函数中自动解锁。

\n

Answer 2

不，std::unique_lock如果与一起使用，则需要a std::condition_variable。std::lock_guard可能会减少开销，但不能与一起使用std::condition_variable。

但是std::unique_lock不需要手动解锁，它也会在超出范围时解锁，例如std::lock_guard。因此，等待代码可以写为：

std::mutex a_mutex;
std::condition_variable a_condition_variable;
{
    std::unique_lock<std::mutex> a_lock(a_mutex);
    a_condition_variable.wait(a_lock, [this] {return something;});
    //Do something
}

参见http://en.cppreference.com/w/cpp/thread/unique_lock

Answer 3

wait()对条件变量的任何调用总是需要lock()和unlock()底层的mutex。由于包装lock_guard<>不提供这些功能，它可以永远与使用wait()。

仍然可以基于编写自己的简单互斥包装lock_guard<>，并添加2种必要方法。另外，您必须使用condition_variable_any，它接受带有lock（）/ unlock（）接口的任何锁/互斥量：

#include <mutex>

template<typename _mutex_t>
class my_lock_guard
{
public:
    explicit my_lock_guard(_mutex_t & __m) : __mutex(__m)
    { __mutex.lock(); }

    my_lock_guard(_mutex_t & __m, std::adopt_lock_t) : __mutex(__m)
    { } // calling thread owns mutex

    ~my_lock_guard()
    { __mutex.unlock(); }

    void lock()
    { __mutex.lock(); }

    void unlock()
    { __mutex.unlock(); }   

    my_lock_guard(const my_lock_guard &) = delete;
    my_lock_guard& operator=(const my_lock_guard &) = delete;

private:
    _mutex_t &  __mutex;
};

然后：

#include <condition_variable>
...
std::mutex m;
my_lock_guard<std::mutex> lg(m);
std::condition_variable_any cva;
cva.wait(lg, [] { return something;});  
// do something ...
...