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

This code creates multiple threads that print their IDs while ensuring that the output is not mixed up.

What happens if I forget to unlock a mutex?

Forgetting to unlock a mutex can lead to a deadlock situation, where the thread holding the lock cannot proceed because it is waiting for the lock to be released. This can cause your program to hang indefinitely.

Are there alternatives to using mutexes?

Yes, alternatives include using reader-writer locks, condition variables, or atomic operations, depending on your specific use case and performance requirements.