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

Ich habe zwei Anwendungsfälle.

A. Ich möchte den Zugriff von zwei Threads auf eine Warteschlange synchronisieren.

B. Ich möchte den Zugriff von zwei Threads auf eine Warteschlange synchronisieren und eine Bedingungsvariable verwenden, da einer der Threads darauf wartet, dass der Inhalt vom anderen Thread in der Warteschlange gespeichert wird.

Für Anwendungsfall AI siehe Codebeispiel using std::lock_guard<>. Für Anwendungsfall-BI siehe Codebeispiel using std::unique_lock<>.

Was ist der Unterschied zwischen den beiden und welchen sollte ich in welchem ​​Anwendungsfall verwenden?

Der Unterschied besteht darin, dass Sie a sperren und entsperren können std::unique_lock. std::lock_guardwird beim Bau nur einmal gesperrt und bei Zerstörung entsperrt.

Für Anwendungsfall B benötigen Sie also definitiv eine std::unique_lockfür die Bedingungsvariable. In Fall A hängt es davon ab, ob Sie den Schutz wieder verriegeln müssen.

std::unique_lockhat andere Funktionen, die es ermöglichen, zB: ohne sofortiges Sperren des Mutex zu konstruieren, aber den RAII-Wrapper zu erstellen (siehe hier ).

std::lock_guardbietet auch einen praktischen RAII-Wrapper, kann jedoch mehrere Mutexe nicht sicher sperren. Es kann verwendet werden, wenn Sie einen Wrapper für einen begrenzten Bereich benötigen, z. B.: Eine Mitgliedsfunktion:

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

Um eine Frage von chmike zu klären, sind standardmäßig std::lock_guardund std::unique_lockgleich. So im obigen Fall, könnten Sie ersetzen std::lock_guardmit std::unique_lock. Allerdings std::unique_lockhaben könnte mehr Aufwand ein bisschen.

Beachten Sie, dass in diesen Tagen sollte man verwenden std::scoped_lockstatt std::lock_guard.

lock_guardund unique_locksind so ziemlich das Gleiche; lock_guardist eine eingeschränkte Version mit einer eingeschränkten Schnittstelle.

A lock_guardhält immer ein Schloss von seiner Konstruktion bis zu seiner Zerstörung. A unique_lockkann ohne sofortige Sperrung erstellt werden, kann zu jedem Zeitpunkt seiner Existenz entsperrt werden und kann das Eigentum an der Sperre von einer Instanz auf eine andere übertragen.

Sie verwenden also immer lock_guard, es sei denn, Sie benötigen die Funktionen von unique_lock. A condition_variablebraucht a unique_lock.

Verwenden lock_guardSie diese Option, es sei denn, Sie müssen in der Lage sein, unlockden Mutex dazwischen manuell zu erstellen, ohne den zu zerstören lock.

condition_variableEntsperrt insbesondere seinen Mutex, wenn er bei Anrufen in den Ruhezustand geht wait. Deshalb lock_guardreicht a hier nicht aus.

Es gibt bestimmte Gemeinsamkeiten zwischen lock_guardund unique_lockund bestimmte Unterschiede.

Im Kontext der gestellten Frage erlaubt der Compiler jedoch nicht die Verwendung einer lock_guardin Kombination mit einer Bedingungsvariablen, da der Mutex automatisch entsperrt wird, wenn ein Thread auf eine Bedingungsvariable wartet, und wenn andere Threads / Threads und der aktuelle Thread benachrichtigt werden wird aufgerufen (kommt aus der Wartezeit), wird die Sperre wiedererlangt.

Dieses Phänomen widerspricht dem Prinzip von lock_guard. lock_guardkann nur einmal konstruiert und nur einmal zerstört werden.

Daher lock_guardkann nicht in Kombination mit einer Bedingungsvariablen verwendet werden, aber a unique_lockkann (weil unique_lockmehrmals gesperrt und entsperrt werden kann).

Sie sind nicht wirklich die gleichen Mutexe, lock_guard<muType>haben fast die gleichen wie std::mutex, mit dem Unterschied, dass ihre Lebensdauer am Ende des Bereichs endet (D-tor genannt), also eine klare Definition dieser beiden Mutexe:

lock_guard<muType> hat einen Mechanismus zum Besitzen eines Mutex für die Dauer eines Bereichsblocks.

Und

unique_lock<muType> ist ein Wrapper, der verzögertes Sperren, zeitlich begrenzte Sperrversuche, rekursives Sperren, Übertragung des Sperrenbesitzes und Verwendung mit Bedingungsvariablen ermöglicht.

Hier ist ein Beispiel für die Implementierung:

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

In diesem Beispiel habe ich das unique_lock<muType>mit verwendetcondition variable

Wie bereits von anderen erwähnt, verfolgt std :: unique_lock den Sperrstatus des Mutex, sodass Sie das Sperren bis nach dem Aufbau des Schlosses verschieben und vor dem Zerstören des Schlosses entsperren können. std :: lock_guard erlaubt dies nicht.

Es scheint keinen Grund zu geben, warum die Wartefunktionen std :: condition_variable nicht sowohl einen lock_guard als auch einen unique_lock verwenden sollten, da der Mutex bei jedem Ende einer Wartezeit (aus welchem ​​Grund auch immer) automatisch neu erfasst wird, sodass keine semantische Verletzung auftritt. Um jedoch einen std :: lock_guard mit einer Bedingungsvariablen zu verwenden, müssen Sie gemäß dem Standard eine std :: condition_variable_any anstelle von std :: condition_variable verwenden.

Bearbeiten : gelöscht "Mit der pthreads-Schnittstelle sollten std :: condition_variable und std :: condition_variable_any identisch sein". Zum Blick auf die Implementierung von gcc:

• std :: condition_variable :: wait (std :: unique_lock &) ruft nur pthread_cond_wait () für die zugrunde liegende pthread-Bedingungsvariable in Bezug auf den von unique_lock gehaltenen Mutex auf (und könnte dies auch für lock_guard tun, aber nicht, weil der Standard dies tut sieht das nicht vor)
• std :: condition_variable_any kann mit jedem abschließbaren Objekt arbeiten, einschließlich eines Objekts, das überhaupt keine Mutex-Sperre ist (es könnte daher sogar mit einem Interprozess-Semaphor funktionieren).