单例模式何以保证线程安全

  extern "C"
  int __cxa_guard_acquire (__guard *g) {
  #ifdef _GLIBCXX_USE_FUTEX //futex是linux内核中锁机制，__atomic_相关的原子操作函数是Intel x86架构上独有的
    // 所以在arm硬件平台上是不支持这些操作的,只能使用mutex进行加锁。
    // If __atomic_* and futex syscall are supported, don't use any global mutex.
   	int *gi = (int *) (void *) g;
	const int guard_bit = _GLIBCXX_GUARD_BIT; // 初始化完成
	const int pending_bit = _GLIBCXX_GUARD_PENDING_BIT; // 正在初始化
	const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT; // 等待初始化
	while (1)
	{
	  int expected(0);
	  if (__atomic_compare_exchange_n(gi, &expected, pending_bit, false,
					    __ATOMIC_ACQ_REL,
					    __ATOMIC_ACQUIRE))
	  {
		// This thread should do the initialization.
		return 1;
	  } 
	 if (expected == guard_bit)
	 {
		// Already initialized.
		return 0;	
	 }
	 if (expected == pending_bit)
	 {
		 // Use acquire here.
		 int newv = expected | waiting_bit;
		 if (!__atomic_compare_exchange_n(gi, &expected, newv, false,
						  __ATOMIC_ACQ_REL, 
						  __ATOMIC_ACQUIRE))
		 {
		     if (expected == guard_bit)
		       {
			 // Make a thread that failed to set the waiting bit exit the function earlier,
			 // if it detects that another thread has successfully finished initialising.
			 return 0;
		 }
		 if (expected == 0)
		    continue;
	 }	 
	 expected = newv;
   }
   syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAIT, expected, 0);
  #else //不适用原子操作，使用mutex加锁
	if (__gthread_active_p ())
    {
		mutex_wrapper mw;
		while (1) // When this loop is executing, mutex is locked.
		{
			// The static is already initialized.
	    	if (_GLIBCXX_GUARD_TEST(g))
	      		return 0;	// The mutex will be unlocked via wrapper
	    	if (init_in_progress_flag(g))
	      	{
		// The guarded static is currently being initialized by
		// another thread, so we release mutex and wait for the
		// condition variable. We will lock the mutex again after
		// this.
				get_static_cond().wait_recursive(&get_static_mutex());
	      	}
	    	else
	      	{
				set_init_in_progress_flag(g, 1);
				return 1; // The mutex will be unlocked via wrapper.
	      	}
		}
	}
  #endif
  }

从上面可以看到如果是在x86上支持原子操作，那么__cxa_guard_acquire会调用__atomic_compare_exchange_n函数进行CAS，对于以__atomic_*开头的函数，在GCC4.7.版本之前是以__sync_*开头的函数，他们之间主要的不同在于__atomic_系列的参数有内存序参数而__sync_系列没有，所以建议使用新的__atomic_系列函数。
对于__atomic_compare_exchange_n函数其中的__ATOMIC_ACQ_REL内存序参数，有以下几种内存序：

__ATOMIC_RELAXED：最低约束等级，表示没有线程间排序约束
__ATOMIC_CONSUME：官方表示因为C++11的memory_order_consume语义不足，当前使用更强的__ATOMIC_ACQUIRE来实现。
__ATOMIC_ACQUIRE：对释放操作创建线程间happens-before限制，防止代码在操作前的意外hoisting
__ATOMIC_RELEASE：对获取操作创建线程间happens-before限制，防止代码在操作后的意外sinking
__ATOMIC_ACQ_REL：结合了前述两种限制
__ATOMIC_SEQ_CST：约束最强，默认

// 比较ptr和expected指向的内容，如果相等，则进行read-modify-write操作，将desired值写入ptr指向的内存中，内存序使用
// success_memorder；若不相等，则进行read操作并将*ptr的内容写到*expected中，内存序使用failure_memorder
// weak为true时表示操作允许失败，一般都是false。
bool __atomic_compare_exchange_n (type *ptr, type *expected, type desired, bool weak, 
	int success_memorder, int failure_memorder)

对于内存模型的种类及作用，这里不做过多的解释，后面另写一篇blog进行阐述。