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

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

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

    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)

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;
}

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);
}

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

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

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;

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);
    }
};

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

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

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

pthread_mutex_t g_guard = PTHREAD_MUTEX_INITIALIZER;

boost::detail::basic_recursive_mutex g_guard = BOOST_BASIC_RECURSIVE_MUTEX_INITIALIZER;

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(<тот-самый мьютекс>);

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);
}

//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

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;
}

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

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

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

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

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 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;
}

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

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;
}

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

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));
}