std :: unique_lock <std :: mutex> или std :: lock_guard <std :: mutex>?

У меня есть два варианта использования.

О. Я хочу синхронизировать доступ двумя потоками к очереди.

Б. Я хочу синхронизировать доступ двух потоков к очереди и использовать условную переменную, поскольку один из потоков будет ожидать сохранения содержимого в очереди другим потоком.

Для варианта использования AI см. Пример кода с использованием std::lock_guard<>. Для варианта использования BI см. Пример кода с использованием std::unique_lock<>.

В чем разница между этими двумя и какой я должен использовать в каком случае использования?

Разница в том, что вы можете заблокировать и разблокировать std::unique_lock. std::lock_guardбудет заблокирован только один раз на строительстве и разблокирован при уничтожении.

Так что для варианта использования B вам определенно нужна std::unique_lockпеременная условия. В случае А это зависит от того, нужно ли вам снова заблокировать охрану.

std::unique_lockимеет другие функции, которые позволяют ему, например: создавать без немедленной блокировки мьютекса, но создавать оболочку RAII (см. здесь ).

std::lock_guardтакже предоставляет удобную оболочку RAII, но не может безопасно заблокировать несколько мьютексов. Его можно использовать, когда вам нужна оболочка для ограниченной области, например, функция-член:

class MyClass{
    std::mutex my_mutex;
    void member_foo() {
        std::lock_guard<mutex_type> lock(this->my_mutex);            
        /*
         block of code which needs mutual exclusion (e.g. open the same 
         file in multiple threads).
        */

        //mutex is automatically released when lock goes out of scope           
};

Для уточнения вопроса по chmike, по умолчанию std::lock_guardи std::unique_lockтак же. Таким образом, в приведенном выше случае, вы можете заменить std::lock_guardна std::unique_lock. Тем не менее, std::unique_lockможет иметь немного больше накладных расходов.

Обратите внимание, что в эти дни следует использовать std::scoped_lockвместо std::lock_guard.

lock_guardи unique_lockв значительной степени одно и то же; lock_guardявляется ограниченной версией с ограниченным интерфейсом.

А lock_guardвсегда держит замок от его строительства до его разрушения. A unique_lockможет быть создан без немедленной блокировки, может разблокироваться в любой момент своего существования и может передавать право собственности на блокировку из одного экземпляра в другой.

Таким образом, вы всегда используете lock_guard, если вам не нужны возможности unique_lock. А condition_variableнужен unique_lock.

Используйте, lock_guardесли вам не нужно вручную unlockмьютекс между ними, не разрушая lock.

В частности, condition_variableразблокирует его мьютекс при переходе в режим ожидания при вызовах wait. Вот почему здесь lock_guardне достаточно.

Есть некоторые общие вещи , между lock_guardи unique_lockи некоторые различия.

Но в контексте заданного вопроса компилятор не позволяет использовать lock_guardв сочетании с условной переменной, потому что, когда поток вызывает ожидание для условной переменной, мьютекс автоматически разблокируется, и когда другие потоки / потоки уведомляют и текущий поток вызывается (выходит из режима ожидания), блокировка восстанавливается.

Это явление противоречит принципу lock_guard. lock_guardможет быть построен только один раз и разрушен только один раз.

Следовательно, lock_guardне может использоваться в комбинации с условной переменной, но unique_lockможет быть (потому что unique_lockможет быть заблокирован и разблокирован несколько раз).

Они на самом деле не одни и те же мьютексы, lock_guard<muType>имеют почти то же самое std::mutex, с той разницей, что их время жизни заканчивается в конце области (называемой D-tor), поэтому четкое определение этих двух мьютексов

lock_guard<muType> имеет механизм владения мьютексом во время блока с ограниченным пространством.

И

unique_lock<muType> является оберткой, допускающей отложенную блокировку, ограниченные по времени попытки блокировки, рекурсивную блокировку, передачу владения блокировкой и использование с переменными условия.

Вот пример реализации:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <chrono>

using namespace std::chrono;

class Product{

   public:

       Product(int data):mdata(data){
       }

       virtual~Product(){
       }

       bool isReady(){
       return flag;
       }

       void showData(){

        std::cout<<mdata<<std::endl;
       }

       void read(){

         std::this_thread::sleep_for(milliseconds(2000));

         std::lock_guard<std::mutex> guard(mmutex);

         flag = true;

         std::cout<<"Data is ready"<<std::endl;

         cvar.notify_one();

       }

       void task(){

       std::unique_lock<std::mutex> lock(mmutex);

       cvar.wait(lock, [&, this]() mutable throw() -> bool{ return this->isReady(); });

       mdata+=1;

       }

   protected:

    std::condition_variable cvar;
    std::mutex mmutex;
    int mdata;
    bool flag = false;

};

int main(){

     int a = 0;
     Product product(a);

     std::thread reading(product.read, &product);
     std::thread setting(product.task, &product);

     reading.join();
     setting.join();


     product.showData();
    return 0;
}

В этом примере я использовал unique_lock<muType>сcondition variable

Как уже упоминалось другими, std :: unique_lock отслеживает заблокированное состояние мьютекса, поэтому вы можете отложить блокировку до окончания построения блокировки и разблокировать до разрушения блокировки. std :: lock_guard не разрешает это.

Кажется, нет никаких причин, по которым функции ожидания std :: condition_variable не должны принимать lock_guard, а также unique_lock, потому что всякий раз, когда ожидание заканчивается (по любой причине), мьютекс автоматически повторно запрашивается, чтобы не вызывать никакого семантического нарушения. Однако в соответствии со стандартом, чтобы использовать std :: lock_guard с условной переменной, вы должны использовать std :: condition_variable_any вместо std :: condition_variable.

Редактировать : удалено «Использование интерфейса pthreads std :: condition_variable и std :: condition_variable_any должны быть идентичны». Рассматривая реализацию gcc:

• std :: condition_variable :: wait (std :: unique_lock &) просто вызывает pthread_cond_wait () для базовой переменной условия pthread по отношению к мьютексу, содержащемуся в unique_lock (и поэтому может в равной степени делать то же самое для lock_guard, но не потому, что стандарт не предусматривает этого)
• std :: condition_variable_any может работать с любым блокируемым объектом, включая тот, который вообще не является блокировкой мьютекса (следовательно, он может работать даже с межпроцессным семафором)