How can I prevent data races in C++ using the thread library?

How can I prevent data races in C++ using the thread library?

To prevent data races in C++, you can use mutexes from the thread library to synchronize access to shared resources.

Can you give me an example of using a mutex?

Sure! Here's a simple example:

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

std::mutex mtx;
int shared_data = 0;

void increment() {
    mtx.lock();
    ++shared_data;
    mtx.unlock();
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << shared_data << std::endl;
}

This code ensures that only one thread can modify shared_data at a time.

What happens if I forget to lock the mutex?

If you forget to lock the mutex, multiple threads may access and modify shared_data simultaneously, leading to unpredictable results and data races.

Are there other synchronization mechanisms I can use?

Yes, besides mutexes, you can use condition variables, locks, and atomic operations for synchronization in C++.