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

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

In C++, a mutex is a synchronization primitive that allows multiple threads to access shared resources safely. A lock_guard, on the other hand, is a convenience wrapper that manages a mutex's locking and unlocking automatically.

Can you explain how lock_guard works with an example?

Sure! Here's a simple example:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printThreadId(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread ID: " << id << '\n';
}

int main() {
    std::thread threads[5];
    for (int i = 0; i < 5; ++i) {
        threads[i] = std::thread(printThreadId, i);
    }
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

In this example, lock_guard ensures that the mutex is locked when a thread enters the printThreadId function and automatically unlocks it when the function exits.

What are the advantages of using lock_guard over manually locking a mutex?

The main advantages of using lock_guard are:

1. Automatic Resource Management: It automatically releases the mutex when it goes out of scope, preventing deadlocks.
2. Exception Safety: If an exception occurs, lock_guard ensures that the mutex is still released, maintaining program stability.

Are there any scenarios where I shouldn't use lock_guard?

Yes, if you need more control over the locking mechanism, such as locking and unlocking the mutex multiple times within a function, you might prefer using std::unique_lock instead of lock_guard.