Does a static object within a function introduce a potential race condition?

Question

I'm curious about the following code:

class MyClass
{
public:
   MyClass() : _myArray(new int[1024]) {}
   ~MyClass() {delete [] _myArray;}

private:
   int * _myArray;
};

// This function may be called by different threads in an unsynchronized manner
void MyFunction()
{
   static const MyClass _myClassObject;
   [...]
}

Is there a possible race condition in the above code? Specifically, is the compiler likely to generate code equivalent to the following, "behind the scenes"?

void MyFunction()
{
   static bool _myClassObjectInitialized = false;
   if (_myClassObjectInitialized == false)
   {
      _myClassObjectInitialized = true;
      _myClassObject.MyClass();   // call constructor to set up object
   }
   [...]
}

... in which case, if two threads were to call MyFunction() nearly-simultaneously, then _myArray might get allocated twice, causing a memory leak?

Or is this handled correctly somehow?

Answer 1

Use a semaphore if you're using multiple threads, its's what they're for.

Answer 2

There's absolutely a possible race condition there. Whether or not there actually is one is pretty damn undefined. You shouldn't use such code in single-threaded scenarios because it's bad design, but it could be the death of your app in multithreaded. Anything that is static const like that should probably go in a convenient namespace, and get allocated at the start of the application.