Is there anything that would make a static bool thread safe?

I recently came across some code that was working fine where a static bool was shared between multiple threads (single writer, multiple receivers) although there was no synchronization.

Something like that (simplified):

//header A
struct A {
   static bool f;
   static bool isF() { return f; }
};

//Source A
bool A::f = false;

void threadWriter(){
    /* Do something */
    A::f = true;
}

// Source B
void threadReader(){
   while (!A::isF()) { /* Do something */}
}

For me, this kind of code has a race condition in that even though operations on bool are atomic (on most CPUs), we have no guarantee that the write from the writer thread will be visible to the reader threads. But some people told me that the fact that f is static would help.

So, is there anything in C++11 that would make this code safe? Or anything related to static that would make this code work?