std :: unique_lock <std :: mutex> atau std :: lock_guard <std :: mutex>?

Saya punya dua kasus penggunaan.

A. Saya ingin menyinkronkan akses oleh dua utas ke antrian.

B. Saya ingin menyinkronkan akses oleh dua utas ke antrian dan menggunakan variabel kondisi karena salah satu utas akan menunggu konten untuk disimpan ke dalam antrian oleh utas lainnya.

Untuk kasus penggunaan, lihat contoh kode menggunakan std::lock_guard<>. Untuk kasus penggunaan BI lihat contoh kode menggunakan std::unique_lock<>.

Apa perbedaan antara keduanya dan yang mana yang harus saya gunakan dalam kasus penggunaan yang mana?

Perbedaannya adalah bahwa Anda dapat mengunci dan membuka kunci a std::unique_lock. std::lock_guardakan dikunci hanya sekali pada konstruksi dan tidak terkunci pada kehancuran.

Jadi untuk kasus penggunaan B Anda pasti membutuhkan std::unique_lockvariabel kondisi. Dalam kasus A itu tergantung apakah Anda perlu mengunci kembali penjaga.

std::unique_lockmemiliki fitur lain yang memungkinkannya misalnya: dibangun tanpa mengunci mutex segera tetapi untuk membangun pembungkus RAII (lihat di sini ).

std::lock_guardjuga menyediakan pembungkus RAII yang nyaman, tetapi tidak dapat mengunci beberapa mutex dengan aman. Ini dapat digunakan ketika Anda membutuhkan pembungkus untuk lingkup terbatas, misalnya: fungsi anggota:

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           
};

Untuk mengklarifikasi pertanyaan dengan chmike, secara default std::lock_guarddan std::unique_locksama. Jadi dalam kasus di atas, Anda bisa menggantinya std::lock_guarddengan std::unique_lock. Namun, std::unique_lockmungkin sedikit lebih mahal.

Perhatikan bahwa hari ini seseorang harus menggunakan std::scoped_locksebagai ganti std::lock_guard.

lock_guarddan hal unique_lockyang hampir sama; lock_guardadalah versi terbatas dengan antarmuka terbatas.

A lock_guardselalu memegang kunci dari konstruksi hingga kehancurannya. A unique_lockdapat dibuat tanpa segera mengunci, dapat membuka pada titik mana pun dalam keberadaannya, dan dapat mentransfer kepemilikan kunci dari satu contoh ke yang lain.

Jadi Anda selalu menggunakan lock_guard, kecuali jika Anda membutuhkan kemampuan unique_lock. SEBUAHcondition_variable membutuhkan unique_lock.

Gunakan lock_guardkecuali Anda harus dapat secara manual unlockmenggunakan mutex di antaranya tanpa merusaknya lock.

Secara khusus, condition_variablemembuka kunci mutunya ketika akan tidur saat panggilan ke wait. Itu sebabnya a lock_guardtidak memadai di sini.

Ada beberapa hal umum antara lock_guarddan unique_lockdan perbedaan tertentu.

Tetapi dalam konteks pertanyaan yang diajukan, kompiler tidak mengizinkan penggunaan a lock_guard kombinasi dengan variabel kondisi, karena ketika sebuah thread panggilan menunggu variabel kondisi, mutex akan dibuka secara otomatis dan ketika thread / utas lainnya memberi tahu dan utas saat ini dipanggil (keluar dari menunggu), kunci diperoleh kembali.

Fenomena ini bertentangan dengan prinsip lock_guard. lock_guarddapat dibangun hanya sekali dan dihancurkan hanya sekali.

Karenanya lock_guardtidak dapat digunakan dalam kombinasi dengan variabel kondisi, tetapi a unique_lockdapat (karena unique_lockdapat dikunci dan dibuka beberapa kali).

Mereka bukan mutex yang benar-benar sama, lock_guard<muType>memiliki hampir sama dengan std::mutex, dengan perbedaan bahwa itu seumur hidup berakhir pada akhir lingkup (D-tor disebut) sehingga definisi yang jelas tentang dua mutex ini:

lock_guard<muType> memiliki mekanisme untuk memiliki mutex untuk durasi blok yang dicakup.

Dan

unique_lock<muType> adalah pembungkus yang memungkinkan penguncian yang tertunda, upaya penguncian terbatas waktu, penguncian rekursif, transfer kepemilikan kunci, dan digunakan dengan variabel kondisi.

Berikut ini contoh penerapannya:

#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;
}

Dalam contoh ini, saya menggunakan unique_lock<muType>dengancondition variable

Seperti yang telah disebutkan oleh orang lain, std :: unique_lock melacak status terkunci dari mutex, sehingga Anda dapat menunda penguncian sampai setelah pembangunan kunci, dan membuka sebelum kerusakan kunci. std :: lock_guard tidak mengizinkan ini.

Tampaknya tidak ada alasan mengapa fungsi menunggu std :: condition_variable tidak boleh mengambil lock_guard serta unique_lock, karena setiap kali menunggu berakhir (untuk alasan apa pun) mutex secara otomatis diperoleh kembali sehingga tidak akan menyebabkan pelanggaran semantik. Namun menurut standar, untuk menggunakan std :: lock_guard dengan variabel kondisi, Anda harus menggunakan std :: condition_variable_any alih-alih std :: condition_variable.

Sunting : dihapus "Menggunakan antarmuka pthreads std :: condition_variable dan std :: condition_variable_any harus identik". Saat melihat implementasi gcc:

• std :: condition_variable :: wait (std :: unique_lock &) hanya memanggil pthread_cond_wait () pada variabel kondisi pthread yang mendasari sehubungan dengan mutex yang dipegang oleh unique_lock (dan dengan demikian bisa sama-sama melakukan hal yang sama untuk lock_guard, tetapi tidak karena standar tidak menyediakan untuk itu)
• std :: condition_variable_any dapat bekerja dengan objek yang dapat dikunci, termasuk yang bukan kunci mutex sama sekali (karena itu bahkan dapat bekerja dengan semafor antar-proses)