std::unique_lock or std::lock_guard?

by

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

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.

More Related Contents:

  1. Start thread with member function
  2. C++0x has no semaphores? How to synchronize threads?
  3. What happens to a detached thread when main() exits?
  4. Thread pooling in C++11
  5. Why is the destructor of a future returned from `std::async` blocking?
  6. What does the thread_local mean in C++11?
  7. How to check if a std::thread is still running?
  8. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  9. What exactly is std::atomic?
  10. How to implement multithread safe singleton in C++11 without using
  11. Difference between pointer and reference as thread parameter
  12. How would you implement your own reader/writer lock in C++11?
  13. Mixing C++11 atomics and OpenMP
  14. Does the C++ volatile keyword introduce a memory fence?
  15. How to set the stacksize with C++11 std::thread
  16. How to give priority to privileged thread in mutex locking?
  17. What causes runtime error message: std::system_error – operation not permitted, including mult-threading? [duplicate]
  18. How can I use something like std::vector?
  19. std::thread is not a member of namespace std using Eclipse Kepler MinGW
  20. What is std::promise?
  21. Passing arguments to std::async by reference fails
  22. Waiting for multiple futures?
  23. What is different between join() and detach() for multi threading in C++?
  24. MinGW error: ‘thread’ is not a member of ‘std’
  25. C++11 std::threads vs posix threads
  26. Understanding std::atomic::compare_exchange_weak() in C++11
  27. Double-Checked Lock Singleton in C++11
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. About thread-safety of weak_ptr

Leave a Comment