What are mutexes and locks in C++?

What are mutexes and locks in C++?

Mutexes (mutual exclusions) are synchronization primitives used to protect shared data from being accessed by multiple threads simultaneously. Locks are mechanisms that allow threads to gain exclusive access to a resource.

How do I implement a mutex in my C++ code?

You can implement a mutex in C++ using the <mutex> header. Here's a simple example:

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

std::mutex mtx;

void printThreadId(int id) {
    mtx.lock();  // Lock the mutex
    std::cout << "Thread ID: " << id << '\n';
    mtx.unlock();  // Unlock the mutex
}

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

What is the difference between a mutex and a lock_guard?

A mutex is a low-level synchronization primitive, while lock_guard is a higher-level RAII wrapper that automatically manages the locking and unlocking of a mutex, ensuring that the mutex is released when the lock_guard goes out of scope.

Can you explain deadlocks and how to avoid them?

Deadlocks occur when two or more threads are waiting for each other to release resources, causing them to be stuck indefinitely. To avoid deadlocks, you can use strategies like acquiring locks in a consistent order, using timeouts, or employing lock-free data structures.