std unique lock std mutex or std lock guard std mutex

Question

I have two use cases  A  I want to synchronise access to a queue for two threads  B  I want to synchronise access to a queue for two threads and use a condition variable because one of the threads will wait on content to be stored into the queue by the other thread  For use case A I see code example using std  lock guard lt  gt   For use case B I see code example using std  unique lock lt  gt   What is the difference between the two and which one should I use in which use case

User · Answer

As has been mentioned by others  std  unique lock tracks the locked status of the mutex  so you can defer locking until after construction of the lock  and unlock before destruction of the lock   std  lock guard does not permit this   There seems no reason why the std  condition variable wait functions should not take a lock guard as well as a unique lock  because whenever a wait ends  for whatever reason  the mutex is automatically reacquired so that would not cause any semantic violation   However according to the standard  to use a std  lock guard with a condition variable you have to use a std  condition variable any instead of std  condition variable   Edit  deleted  Using the pthreads interface std  condition variable and std  condition variable any should be identical    On looking at gcc s implementation    std  condition variable  wait std  unique lock amp   just calls pthread cond wait   on the underlying pthread condition variable with respect to the mutex held by unique lock  and so could equally do the same for lock guard  but doesn t because the standard doesn t provide for that  std  condition variable any can work with any lockable object  including one which is not a mutex lock at all  it could therefore even work with an inter-process semaphore

User · Answer

They are not really same mutexes  lock guard lt muType gt  has nearly the same as std  mutex  with a difference that it s lifetime ends at the end of the scope  D-tor called  so a clear definition about these two mutexes        lock guard lt muType gt  has a mechanism for owning a mutex for the duration of a scoped block    And     unique lock lt muType gt  is a wrapper allowing deferred locking  time-constrained attempts at locking  recursive locking  transfer of lock ownership  and use with condition variables    Here is an example implemetation     include  lt iostream gt   include  lt thread gt   include  lt mutex gt   include  lt condition variable gt   include  lt functional gt   include  lt chrono gt   using namespace std  chrono   class Product      public          Product int data  mdata data                    virtual Product                     bool isReady           return flag                   void showData             std  cout lt  lt mdata lt  lt std  endl                   void read              std  this thread  sleep for milliseconds 2000              std  lock guard lt std  mutex gt  guard mmutex             flag   true            std  cout lt  lt  Data is ready  lt  lt std  endl            cvar notify one                      void task            std  unique lock lt std  mutex gt  lock mmutex           cvar wait lock    amp   this    mutable throw   - gt  bool  return this- gt 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   amp product        std  thread setting product task   amp product         reading join         setting join           product showData        return 0      In this example  i used the unique lock lt muType gt  with condition variable

User · Answer

One missing difference is  std  unique lock can be moved but std  lock guard can t be moved  Note  Both cant be copied

User · Answer

The difference is that you can lock and unlock a std  unique lock  std  lock guard will be locked only once on construction and unlocked on destruction  So for use case B you definitely need a std  unique lock for the condition variable  In case  A it depends whether you need to relock the guard  std  unique lock has other features that allow it to e g   be constructed without locking the mutex immediately but to build the RAII wrapper  see here   std  lock guard also provides a convenient RAII wrapper  but cannot lock multiple mutexes safely  It can be used when you need a wrapper for a limited scope  e g   a member function  class MyClass      std  mutex my mutex      void member foo             std  lock guard lt mutex type gt  lock this- gt 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                      To clarify a question by chmike  by default std  lock guard and std  unique lock are the same  So in the above case  you could replace std  lock guard with std  unique lock  However  std  unique lock might have a tad more overhead  Note that these days  since  C  17  one should use std  scoped lock instead of std  lock guard

User · Answer

lock guard and unique lock are pretty much the same thing  lock guard is a restricted version with a limited interface   A lock guard always holds a lock from its construction to its destruction  A unique lock can be created without immediately locking  can unlock at any point in its existence  and can transfer ownership of the lock from one instance to another   So you always use lock guard  unless you need the capabilities of unique lock  A condition variable needs a unique lock

User · Answer

Use lock guard unless you need to be able to manually unlock the mutex in between without destroying the lock  In particular  condition variable unlocks its mutex when going to sleep upon calls to wait  That is why a lock guard is not sufficient here  If you re already on C  17 or later  consider using scoped lock as a slightly improved version of lock guard  with the same essential capabilities

User · Answer

There are certain common things between lock guard and unique lock and certain differences    But in the context of the question asked  the compiler does not allow using a lock guard in combination with a condition variable  because when a thread calls wait on a condition variable  the mutex gets unlocked automatically and when other thread threads notify and the current thread is invoked  comes out of wait   the lock is re-acquired    This phenomenon is against the principle of lock guard  lock guard can be constructed only once and destructed only once    Hence lock guard cannot be used in combination with a condition variable  but a unique lock can be  because unique lock can be locked and unlocked several times

[c++] std::unique_lock<std::mutex> or std::lock_guard<std::mutex>?

Examples related to c++

Examples related to multithreading

Examples related to c++11

Examples related to mutual-exclusion

Examples related to stdmutex