What are some examples of race conditions in C++?

What are some examples of race conditions in C++?

Race conditions occur when multiple threads access shared data simultaneously, leading to unpredictable results. For example, if two threads increment the same variable without proper synchronization, the final value may not reflect all increments.

Can you give me a specific code example?

Sure! Here's a simple example:

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<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.load() << std::endl;
}

In this example, using std::atomic prevents race conditions.

What happens if I don't use atomic variables?

If you don't use atomic variables, the final value of counter may be less than 2000 due to race conditions. This happens because both threads may read and write the value simultaneously, causing some increments to be lost.

How can I prevent race conditions in my code?

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