std :: unique_lock <std :: mutex> або std :: lock_guard <std :: mutex>?

У мене є два випадки використання.

A. Я хочу синхронізувати доступ двома потоками до черги.

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

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

Яка різниця між цими двома та якими слід користуватися у разі використання?

Різниця полягає в тому, що ви можете заблокувати та розблокувати a std::unique_lock. std::lock_guardбуде заблокований лише один раз на конструкції та розблокований при знищенні.

Тому для використання випадку B вам обов'язково потрібна std::unique_lockзмінна умова. У випадку A, це залежить від того, чи потрібно вимкнути охорону.

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це обмежена версія з обмеженим інтерфейсом.

A lock_guardзавжди тримає замок від його будівництва до руйнування. А 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комбінацію зі змінною умови, тому що, коли потік викликає зачекання на змінну умови, mutex автоматично розблокується та коли інші потоки / потоки сповіщають і поточний потік викликається (виходить з очікування), замок знову набувається.

Це явище суперечить принципу 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, а також унікальний_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 стосовно mutex, що міститься у файлі unique_lock (і так би можна було однаково зробити те саме для lock_guard, але не тому, що стандарт не передбачає цього)
• std :: condition_variable_any може працювати з будь-яким об'єктом, що блокується, включаючи той, який взагалі не є блокуванням mutex (тому він може працювати навіть із міжпроцесорним семафором)