Why does code mutating a shared variable across threads apparently NOT suffer from a race condition?

Question

I'm using Cygwin GCC and run this code:

#include <iostream> #include <thread> #include <vector> using namespace std;  unsigned u = 0;  void foo() {     u++; }  int main() {     vector<thread> threads;     for(int i = 0; i < 1000; i++) {         threads.push_back (thread (foo));     }     for (auto& t : threads) t.join();      cout << u << endl;     return 0; } 

Compiled with the line: g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.o.

It prints 1000, which is correct. However, I expected a lesser number due to threads overwriting a previously incremented value. Why does this code not suffer from mutual access?

My test machine has 4 cores, and I put no restrictions on the program that I know of.

The problem persists when replacing the content of the shared foo with something more complex, e.g.

if (u % 3 == 0) {     u += 4; } else {     u -= 1; } 

Answer 1

foo() is so short that each thread probably finishes before the next one even gets spawned. If you add a sleep for a random time in foo() before the u++, you may start seeing what you expect.