LONG CreateUniqueID()
    {
        static LONG id = 0;

        return id++;
    }

    LONG CreateUniqueID()
    {
        static volatile LONG id = 0;

        return InterlockedIncrement( &id );
    }

S>    LONG CreateUniqueID()
S>    {
S>        static volatile LONG id = 0;
S>        return InterlockedIncrement( &id );
S>    }
S>

long id = 0;

struct cache_t
{
  long id;
  long end;

  static long const bucket = 128;
};
__declspec(thread) cache_t cache;

long CreateUniqueID()
{
  cache_t* c = cache;
  if (c->id != c->end)
  {
    // local fast-path
    return c->id++;
  }
  return CreateUniqueIDSlow();
}

// slow-path
__noinline
long CreateUniqueIDSlow()
{
  cache_t* c = cache;
  c->id = InterlockedExchangeAdd(&id, cache::bucket);
  c->end = c->id + cache::bucket;
  return c->id++;
}

6.7 Declaration statement

4.
The zero-initialization (8.5) of all local objects with static storage duration (3.7.1) is performed before any other initialization takes place.

A local object of POD type (3.9) with static storage duration initialized with constant-expressions is initialized before its block is first entered.
An implementation is permitted to perform early initialization of other local objects with static storage duration under the same conditions that an implementation is permitted to statically initialize an object with static storage duration in namespace scope (3.6.2).

Otherwise such an object is initialized the first time control passes through its declaration; such an object is considered initialized upon the completion of its initialization.

unsigned char _interlockedbittestandset(long *a, long b)

unsigned char _interlockedbittestandset(long volatile *a, long b)

int g = 37;

int g = rand();

class mutex
{
public:
  mutex() constexpr
    : state(0)
    , owner(-1)
    , do_debug_checks(true)
  {}

  //...

private:
  uintptr_t state;
  uintptr_t owner;
  bool do_debug_checks;  
};

mutex g_mutex; // <--- статическая инициализация

S>    LONG CreateUniqueID()
S>    {
S>        static LONG id = 0;

S>        return id++;
S>    }
S>

uint32_t noninterruptable_fetch_and_add(uint32_t* p, uint32_t a)
{
    uint32_t val;
    __asm
    {
        mov     eax,        a;
        mov     edi,        p;
        xadd    [edi],      eax;
        mov     val,        eax;
    }
    return val;
}