long i; // глобальная переменная

AG>void f() // вызывается из нескольких потоков выполнения одновременно
AG>{
AG>  i = OSVersion(); // возврашает каждый раз одно и то же
AG>  /* дальше используется i. больше нигде она не используется */
AG>}

void init()
{
  if (initialized)
    return;
  data.p1 = ::GetModuleHandle(...);
  data.p2 = ::GetProcAddress(...);
  data.i3 = (int)sqrt(42*_WIN_VER);
  initialized = true;
}

void init()
{
  if (initialized)
    return;
  data.p1 = ::GetModuleHandle(...);
  initialized = true;
  data.p2 = ::GetProcAddress(...);
  data.i3 = (int)sqrt(42*_WIN_VER);
}

struct data_t
{
  void * p1;
  void * p2;
  int  i3;
  ...
} data = {0};

data_t* p_data = 0;

data_t* init()
{
    data_t* p = p_data;
    _ReadWriteBarrier();
    if (p)
        return p;
    data.p1 = ::GetModuleHandle(...);
    data.p2 = ::GetProcAddress(...);
    data.i3 = (int)sqrt(42*_WIN_VER);
    *((data_t* volatile*)(&p_data)) = &data;
    return p_data;
}

//data.h
struct data_t
{
    void * p1;
    void * p2;
    int  i3;
    //...
};

template<typename>
struct data_initializer
{
    static unsigned counter;
    static data_t data;

    data_initializer()
    {
        if (++counter == 1)
        {
            data.p1 = ::GetModuleHandle(0);
            data.p2 = ::GetProcAddress(0, 0);
            data.i3 = (int)(42*_WIN32_WINNT);
        }
    }

    ~data_initializer()
    {
        if (--counter == 0)
        {
            // deinitialize data - nobody uses it now
        }
    }
};

template<typename T>
unsigned data_initializer<T>::counter = 0;

template<typename T>
data_t data_initializer<T>::data = {};

static data_initializer<void> data_initializer_; // internal linkage

volatile char x = 0;
volatile char y = 0;

// thread 1
x = 1;
short r1 = *(volatile short*)&x;

// thread 2
y = 1;
short r2 = *(volatile short*)&x;

struct S { S() }

S s1;

struct X
{
  static S s2;
}

S X::s2;

S s3;

struct S1
{
  int i;
} s2 = {1};

struct S2
{
  int i;
  S2() : i(1) {}
} s2 = 1;

struct data_t
{
  static data_t* getInstance()
  {
    QMutexLocker locker(&mutex);
    static data_t* instance = new data_t;
    return instance;
  }
  static QMutex mutex;
};

R>>

volatile long x = 0;
volatile long y = 0;
....
//Processor A
x = 1;
long r1 = y;
....
//Processor B
y = 1;
long r2 = x;

A memory barrier prevents the compiler from optimizing memory accesses across the barrier, but enables the compiler to still optimize instructions between barriers.

Marking memory with a memory barrier is similar to marking memory with the volatile (C++) keyword.

AG>struct data_t
AG>{
AG>  void * p1;
AG>  void * p2;
AG>  int  i3;
AG>  ...
AG>} data = {0};

AG>data_t* p_data = 0;

AG>data_t* init()
AG>{
AG>    if (p_data)
AG>        return p_data;
AG>    _ReadWriteBarrier();
AG>    data.p1 = ::GetModuleHandle(...);
AG>    data.p2 = ::GetProcAddress(...);
AG>    data.i3 = (int)sqrt(42*_WIN_VER);
AG>    _mm_mfence();
AG>    p_data = &data;
AG>    return p_data;
AG>}
AG>

//.....
*((data_t* volatile*)(&p_data)) = &data;
return p_data;

R>pthread_mutex_t g_guard = PTHREAD_MUTEX_INITIALIZER;
R>

R>boost::detail::basic_recursive_mutex g_guard = BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER;
R>

class Globals
{
    static Globals* instance_;
public:
    Globals*
    getInstance() // nothrow
    {
        HANDLE guard = CreateMutex(0, false, "unique-name-of-your-taste");
        if (NULL == guard)
        {
            return 0;
        }

        if (WAIT_FAILED == ::WaitForSingleObject(impl, INFINITE))
        {
            return 0;
        }

        if (0 == globals_)
        {
            globals_ = new (std::nothrow) Globals();
        }

        ::ReleaseMutex(guard);

        return globals_;
    }
};

delete globals_;
::CloseHandle(<тот-самый мьютекс>);

enum InitStatus { NotSet, InProgress, Complete };

template<class Fun>
void do_once(long volatile* status, Fun fun)
{
    switch( InterlockedCompareExchange(status, InProgress, NotSet) )
    {
    case NotSet:
        fun();
        InterlockedExchange(status, Complete);
        return;
    case InProgress:
        while( InterlockedCompareExchange(status, InProgress, InProgress) != Complete )
            Sleep();
        return;
    case Complete:
        return;
    default:
        assert(false);
    }
}

struct StaticCS // POD
{
    long volatile status;
    CRITICAL_SECTION cs;
    
    void init()
    {
        do_once(&status, boost::bind(InitializeCriticalSection, &cs));
    }
    
    void enter()
    {
        init();
        EnterCriticalSection(&cs);
    }
    void leave()
    {
        assert(status==Complete);
        LeaveCriticalSection(&cs);
    }
};

sc>void f() // вызывается из нескольких потоков выполнения одновременно
sc>{
sc>    static long const i = OSVersion(); // возврашает каждый раз одно и то же
sc>  /* дальше используется i. больше нигде она не используется */
sc>}
sc>

    static long i = OSVersion(); // возврашает каждый раз одно и то же
0041142D  mov         eax,dword ptr [$S1 (41817Ch)] 
00411432  and         eax,1 
00411435  jne         f+6Ch (41145Ch) 
00411437  mov         eax,dword ptr [$S1 (41817Ch)] 
0041143C  or          eax,1 
0041143F  mov         dword ptr [$S1 (41817Ch)],eax 
//тыдымс, переменная "мы проинициализировались" уже true, но сама переменная i еще не проинициализирована
//если сейчас управление получит другой поток - будет ой
00411444  mov         dword ptr [ebp-4],0 
0041144B  call        OSVersion (411104h)

long i; // глобальная переменная

void f() // вызывается из нескольких потоков выполнения одновременно
{
  i = OSVersion(); // возврашает каждый раз одно и то же
  /* дальше используется i. больше нигде она не используется */
}

void f() // вызывается из нескольких потоков выполнения одновременно
{
    static long const i = OSVersion(); // возврашает каждый раз одно и то же
  /* дальше используется i. больше нигде она не используется */
}

A race condition is a flaw in a system or process whereby the output and/or result of the process is unexpectedly and critically dependent on the sequence or timing of other events.

3.8/6
The memory occupied by any object of static storage duration shall be
zero-initialized at program startup before any other initialization
takes place. [Note: in some cases, additional initialization is done
later. ]

struct data_t
{
  void * p1;
  void * p2;
  int  i3;
  ...
  bool initialized;
} data = {0};

void init()
{
  if (initialized)
    return;
  data.p1 = ::GetModuleHandle(...);
  data.p2 = ::GetProcAddress(...);
  data.i3 = (int)sqrt(42*_WIN_VER);
  initialized = true;
}

AG>Т.е никакая не init-once, скорее init-Nce

void perfect_assign(long& var, long value)
{
    long old = InterlockedCompareExchange(&var, value, 0); // перезаписываем, только если там 0
    assert(old == 0 || old == value);
}

long perfect_read(long& var) // для проверки initialized
{
    return InterlockedCompareExchange(&var, 0, 0); // единственная засада - это создаётся барьер памяти
}

  if (initialized)
    return;
  // тут даже не важно, что вообще инициируется
  initialized = true;

struct data_t
{
  ...
} data = {0};

long volatile initialized = FALSE;

void init()
{
  if (!initialized)
    return;
  data_t local_data;
  /* инициализация local_data */
  ...
  if (::InterlockedExchange(&initialized, TRUE))
    memcpy(&data, local_data, sizeof(data_t);
}

AG>struct data_t
AG>{
AG>  ...
AG>} data = {0};

AG>long volatile initialized = FALSE;

AG>void init()
AG>{
AG>  if (!initialized)
AG>    return;
AG>  data_t local_data;
AG>  /* инициализация local_data */
AG>  ...
AG>  if (::InterlockedExchange(&initialized, TRUE))
AG>    memcpy(&data, local_data, sizeof(data_t);
AG>}
AG>

struct data_t
{
  static data_t* getInstance()
  {
    lock(); // например с помощью мьютекса
    static data_t* instance = new data_t;
    unlock();
    return instance;
  }
};

struct T{
  static T& instance() {
    static T t;
    return t;
  }
};

struct T_init {
  T_init() { T::instance(); }
} const t_init;

pthread_mutex_t g_guard = PTHREAD_MUTEX_INITIALIZER;

boost::detail::basic_recursive_mutex g_guard = BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER;

Simple reads and writes to properly-aligned 32-bit variables are atomic operations. In other words, you will not end up with only one portion of the variable updated; all bits are updated in an atomic fashion. However, access is not guaranteed to be synchronized. If two threads are reading and writing from the same variable, you cannot determine if one thread will perform its read operation before the other performs its write operation.

Simple reads and writes to properly aligned 64-bit variables are atomic on 64-bit Windows. Reads and writes to 64-bit values are not guaranteed to be atomic on 32-bit Windows. Reads and writes to variables of other sizes are not guaranteed to be atomic on any platform.

R>struct data_t
R>{
R>  void * p1;
R>  void * p2;
R>  int  i3;
R>  ...
R>} data = {0};

R>data_t* p_data = 0;

R>data_t* init()
R>{
R>    data_t* p = p_data;
R>    _ReadWriteBarrier();
R>    if (p)
R>        return p;
R>    data.p1 = ::GetModuleHandle(...);
R>    data.p2 = ::GetProcAddress(...);
R>    data.i3 = (int)sqrt(42*_WIN_VER);
R>    *((data_t* volatile*)(&p_data)) = &data;
R>    return p_data;
R>}
R>

R>

TCHAR mutexName[50];
_tprintf_s(mutex, _T("Local\\8E6EB8AF-5DA9-4667-B922-E10F7CA64F62_%d"), ::GetCurrentProcessId());
HANDLE guard = CreateMutex(0, FALSE, mutexName);

HANDLE guard = CreateMutex(0, false, "unique-name-of-your-taste");
if (NULL == guard)
{
    return 0;
}
const bool closeHandle = (ERROR_ALREADY_EXISTS == ::GetLastError());
...
if (closeHandle)
{
    CloseHandle(guard);
}

Windows 2000: Do not create a named synchronization object in DllMain because the system will then load an additional DLL.

//data.h
struct data_t
{
    void * p1;
    void * p2;
    int  i3;
    //...
};

template<typename>
struct data_initializer
{
    static unsigned counter;
    static data_t data;

    data_initializer()
    {
        if (++counter == 1)
        {
            data.p1 = ::GetModuleHandle(0);
            data.p2 = ::GetProcAddress(0, 0);
            data.i3 = (int)(42*_WIN32_WINNT);
        }
    }

    ~data_initializer()
    {
        if (--counter == 0)
        {
            // deinitialize data - nobody uses it now
        }
    }
};

template<typename T>
unsigned data_initializer<T>::counter = 0;

template<typename T>
data_t data_initializer<T>::data = {};

static data_initializer<void> data_initializer_; // internal linkage

R>

data_t* init()
{
    data_t* p = p_data;
    if (p)
        return p;
    data.p1 = ::GetModuleHandle(...);
    data.p2 = ::GetProcAddress(...);
    data.i3 = (int)sqrt(42*_WIN_VER);
   _WriteBarrier();
    p_data = &data;
    return p_data;
}

Because Kernel32.dll is guaranteed to be loaded in the process address space when the entry-point function is called, calling functions in Kernel32.dll does not result in the DLL being used before its initialization code has been executed.

    data_t* p = p_data;
    _ReadWriteBarrier();
    if (p)
        return p;
    data.p1 = ::GetModuleHandle(...);

    if (p_data)
        return p_data;
    _ReadWriteBarrier();
    data.p1 = ::GetModuleHandle(...);

Marking memory with a memory barrier is similar to marking memory with the volatile (C++) keyword.

data_t* init()
{
    data_t* p = p_data;
    if (p)
        return p;
    data.p1 = ::GetModuleHandle(...);
    data.p2 = ::GetProcAddress(...);
   _WriteBarrier();
    p_data = &data;
    data.i3 = (int)sqrt(42*_WIN_VER);
    return p_data;
}

  int i = 1;
004131AD  mov         dword ptr [ebp-228h],1 
  _ReadWriteBarrier();
  ++i;
004131B7  mov         eax,dword ptr [ebp-228h] 
004131BD  add         eax,1 
004131C0  mov         dword ptr [ebp-228h],eax 
  _ReadWriteBarrier();


  volatile int j = 1;
004131C6  mov         dword ptr [ebp-234h],1 
  ++j;
004131D0  mov         eax,dword ptr [ebp-234h] 
004131D6  add         eax,1 
004131D9  mov         dword ptr [ebp-234h],eax

  int i = 1;
000000014000214B  mov         dword ptr [rsp+248h],1 
  _ReadWriteBarrier();
  ++i;
0000000140002156  mov         eax,dword ptr [rsp+248h] 
000000014000215D  add         eax,1 
0000000140002160  mov         dword ptr [rsp+248h],eax 
  _ReadWriteBarrier();


  volatile int j = 1;
0000000140002167  mov         dword ptr [rsp+24Ch],1 
  ++j;
0000000140002172  mov         eax,dword ptr [rsp+24Ch] 
0000000140002179  add         eax,1 
000000014000217C  mov         dword ptr [rsp+24Ch],eax

MSDN, volatile:
This allows volatile objects to be used for memory locks and releases in multithreaded applications

is similar to marking memory with the volatile (C++) keyword

R>

struct data_t
{
  void * p1;
  void * p2;
  int  i3;
  ...
} data = {0};

data_t* p_data = 0;

data_t* init()
{
    if (p_data)
        return p_data;
    _ReadWriteBarrier();
    data.p1 = ::GetModuleHandle(...);
    data.p2 = ::GetProcAddress(...);
    data.i3 = (int)sqrt(42*_WIN_VER);
    _mm_mfence();
    p_data = &data;
    return p_data;
}

AG>>struct data_t
AG>>{
AG>>  void * p1;
AG>>  void * p2;
AG>>  int  i3;
AG>>  ...
AG>>} data = {0};

AG>>data_t* p_data = 0;

AG>>data_t* init()
AG>>{
AG>>    if (p_data)
AG>>        return p_data;
AG>>    _ReadWriteBarrier();
AG>>    data.p1 = ::GetModuleHandle(...);
AG>>    data.p2 = ::GetProcAddress(...);
AG>>    data.i3 = (int)sqrt(42*_WIN_VER);
AG>>    _mm_mfence();
AG>>    p_data = &data;
AG>>    return p_data;
AG>>}
AG>>

data_t* init()
{
    if (p_data)
       return p_data;
    _ReadWriteBarrier();
    data.p1 = ::GetModuleHandle(...);
    data.p2 = ::GetProcAddress(...);
    data.i3 = (int)sqrt(42*_WIN_VER);
#if defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64)
    // soft write barrier is enough
    _WriteBarrier();
    p_data = &data;
#else
    #error add a proper barrier for this architecture
#endif
    return p_data;
}

AG>data_t* init()
AG>{
AG>    if (p_data)
AG>       return p_data;
AG>    _ReadWriteBarrier();
AG>    data.p1 = ::GetModuleHandle(...);
AG>    data.p2 = ::GetProcAddress(...);
AG>    data.i3 = (int)sqrt(42*_WIN_VER);
AG>#if defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64)
AG>    // soft write barrier is enough
AG>    _WriteBarrier();
AG>    p_data = &data;
AG>#else
AG>    #error add a proper barrier for this architecture
AG>#endif
AG>    return p_data;
AG>}
AG>

    //.....
    ::InterlockedExchangePointer(reinterpret_cast<void**>(&p_data), &data);

Q>    //.....
Q>    ::InterlockedExchangePointer(reinterpret_cast<void**>(&p_data), &data);
Q>

This function generates a full memory barrier (or fence) to ensure that memory operations are completed in order.

Q>    //.....
Q>    ::InterlockedExchangePointer(reinterpret_cast<void**>(&p_data), &data);
Q>

struct data_t
{
  void * p1;
  void * p2;
  int  i3;
} data = {0};

union
{
  data_t* d;
  void volatile* p;
} p_data;

 
data_t* init()
{
  if (p_data.d)
    return p_data.d;
  if (void * d = InterlockedCompareExchangePointer(&p_data.p, 0, 0))
    return reinterpret_cast<data_t*>(d);
  data.p1 = ::GetModuleHandle(...);
  data.p2 = ::GetProcAddress(...);
  data.i3 = (int)sqrt(42*_WIN_VER);
  return reinterpret_cast<data_t*>(
    InterlockedExchangePointer(&p_data.p, &data));
}