Is C++ static member variable initialization thread-safe?

Question

According to following resources, in C++(Specially Visual C++) scoped static variable initialization isn't thread safe. But, global static variables are safe.

Thread-safe static variables without mutexing?

http://blogs.msdn.com/oldnewthing/archive/2004/03/08/85901.aspx

So, is following code with static member variable thread-safe?

class TestClass
{
public:
   static MyClass m_instance;
}

Myclass TestClass::m_instance;

Thanks in advance!

Mcswain

Seems true even 5 years after: blogs.msdn.com/b/vcblog/archive/2013/12/02/… (see "Magic statics") :) – Downstroke

Apparently, VS 2015 finally fixes this – Spermatium

Answer 1

It's more a question of function-scoped static variables vs. every other kind of static variable, rather than scoped vs. globals.

All non-function-scope static variables are constructed before main(), while there is only one active thread. Function-scope static variables are constructed the first time their containing function is called. The standard is silent on the question of how function-level statics are constructed when the function is called on multiple threads. However, every implementation I've worked with uses a lock around the constructor (with a twice-checked flag) to guarantee thread-safety.

Solecism

The standard is also silent on how non-function-scoped statics are constructed with multiple threads. IIRC all that is guaranteed is that the object is initialized before any other code in the translation unit is executed (that is, code not called by initializers). If you consider the code might be in a dll loaded after main() begins executing, you see that this is the best that realistically can be guaranteed. It's the particular threading specification that makes any further guarantees, not the C++ standard. – Crumby

g++ (as in GCC) guarantees thread safe initialization of both global and function static variables and plants the required code to block other threads during initialization. – Nita

gcc uses locks to make function level statics threadsafe (can be disabled by a flag). Most (all?) versions of Visual C++ do NOT have threadsafe function level statics. – Evaporation

In C++11 std::call_once can be used to ensure that initialization only happens once across threads. – Toffey

Answer 2

Yes(*). When global statics are initialized, there is only one thread around and all constructors are called on it. This is not true for function's statics, though.

(*) One can possibly make global statics not thread-safe by creating threads in some of the constructors and scheduling some initialization stages on these threads. In this case usual thread safety rules apply.

Spiry

I may create threads in constructors if it's the last program I am writing ;-) – Mcswain

@Varuna: sometimes you don't have a choice or you don't even know that threads are created in your constructors. This usually happens when objects which are being constructed are using third-party libraries. – Spiry