What are some common race condition examples in C++?

What are some common race condition examples in C++?

Race conditions occur when multiple threads access shared data simultaneously, leading to unpredictable results. A common example is when two threads increment a shared counter without proper synchronization.

Can you explain how this happens in code?

Sure! Here's a simple example:

#include <iostream>
#include <thread>

int counter = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final counter value: " << counter << std::endl;
}

In this code, both threads increment the counter variable, which can lead to a race condition.

How can I prevent race conditions in my code?

You can prevent race conditions by using synchronization mechanisms like mutexes. For example, wrapping the increment operation in a mutex lock ensures that only one thread can modify the counter at a time.

Can you show me how to implement a mutex in this example?

Absolutely! Here's the modified code using a mutex:

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

int counter = 0;
std::mutex mtx;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();
        ++counter;
        mtx.unlock();
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final counter value: " << counter << std::endl;
}

Now, the mutex ensures that only one thread can increment the counter at a time.