What are threading locks in C++14?

What are threading locks in C++14?

Threading locks in C++14 are synchronization mechanisms that prevent data races by controlling access to shared resources.

Can you explain the different types of locks available?

Sure! C++14 provides several types of locks, including mutexes, recursive mutexes, and shared mutexes, each serving different use cases.

How do I implement a basic mutex lock?

To implement a basic mutex lock, you can use std::mutex. Here's a simple example:

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

std::mutex mtx;

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

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 safely print their IDs.

What happens if I forget to unlock the mutex?

If you forget to unlock the mutex, it can lead to a deadlock situation where other threads are unable to acquire the lock, causing your program to hang.