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 simultaneously by multiple threads. 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?

A mutex is a specific type of lock that provides mutual exclusion, ensuring that only one thread can access a resource at a time. A lock can refer to various synchronization mechanisms, including mutexes, but not all locks are mutexes.

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 resource ordering, timeout mechanisms, or using lock-free data structures.