What is the difference between lock_guard and unique_lock in C++?

What is the difference between lock_guard and unique_lock in C++?

Both lock_guard and unique_lock are used for managing mutexes in C++. The main difference is that lock_guard is a simpler, lightweight option that locks a mutex when created and unlocks it when destroyed, while unique_lock offers more flexibility, allowing for deferred locking, manual unlocking, and re-locking.

When should I use unique_lock instead of lock_guard?

You should use unique_lock when you need more control over the locking mechanism, such as when you want to lock and unlock the mutex multiple times or when you need to pass the lock to another function.

Are there any performance differences between the two?

Yes, lock_guard is generally more efficient because it has less overhead due to its simplicity. However, if you need the features of unique_lock, the performance cost may be justified.

Can you give an example of using both in code?

Sure! Here's a simple example:

#include <mutex>

std::mutex mtx;

void example() {
    lock_guard<std::mutex> lg(mtx); // Automatically locks and unlocks
    // critical section
}

void exampleWithUniqueLock() {
    unique_lock<std::mutex> ul(mtx, defer_lock);
    // do some work
    ul.lock(); // lock when needed
    // critical section
    ul.unlock(); // unlock when done
}