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 a shared counter 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 helps prevent race conditions.

What happens if I don't use atomic?

If you don't use atomic operations, the final value of the counter may be less than 2000 due to race conditions. This happens because both threads may read the same value before either writes back the incremented value, leading to lost updates.

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 shared resource at a time.