是否可以使用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與std::lock_guard呢？這可以減輕我每次使用它時手動解鎖鎖。

Answer 1

不，如果它與std::condition_variable使用需要一個std::unique_lock。 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 2

不可能，但你並不需要那個。

std::unique_lock自動unlocks itself in destructor，如果它被鎖定。

Answer 3

條件變量來wait()任何調用總是需要lock()和unlock()底層mutex。由於包裝lock_guard<>不提供這些功能，因此可以使用從不使用與wait()一起使用。

不過你可以根據lock_guard<>寫自己的簡單互斥的包裝，並添加2種必要的方法。此外，你將不得不使用condition_variable_any，它接受任何鎖/互斥與鎖（）/解鎖（）接口：

#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 ... 
...