跨线程解锁安全的spinlock

	static pthread_spinlock_t lock;

	__attribute__((constructor))
	void lock_constructor () {
	    if ( pthread_spin_init ( &lock, 0 ) != 0 ) {
	        exit ( 1 );
	    }
	}

	int func(xx) {
	  int ret = 0;
	  if (xx) {
	    ret = ERR1;
	    goto exit;
	  }
	  pthread_spin_lock(&lock);
	  if (xx) {
	    ret = ERR2;
	    goto exit;
	  }
	exit:
	  pthread_spin_unlock(&lock);
	  return 0;
	}

	__attribute__((destructor))
	void lock_destructor () {
	    if ( pthread_spin_destroy ( &lock ) != 0 ) {
	        exit ( 3 );
	    }
	}

	    /*
	     * Copyright (C) Igor Sysoev
	     * Copyright (C) Nginx, Inc.
	     */


	    #include <ngx_config.h>
	    #include <ngx_core.h>

	    //Function: to achieve spin atomic operation lock method based on ngx_spinlock
	    //Parameter interpretation:
	    //lock: Lock the atomic variable expression
	    //value: Flag, whether the lock is a process
	    //spin: In a multi processor system, when the ngx_spinlock method did not get the lock, the current process in a scheduling kernel in the waiting for the other processors to release the lock time
	    void
	    ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin)
	    {

	    #if (NGX_HAVE_ATOMIC_OPS)//Support atomic operations

	        ngx_uint_t  i, n;

	        //Has been in circulation, until the lock is acquired
	        for ( ;; ) {

	            //Lock 0 said no other process holding the lock, then the lock value indicates the current process holding the lock is set to value parameters
	            if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
	                return;
	            }

	            //If it is a multi processor system
	            if (ngx_ncpu > 1) {
	                for (n = 1; n <spin; n <<= 1) {
	                    //With the increasing number of the actual to wait, inspection interval and lock more
	                    for (i = 0; i <n; i++) {
	                        ngx_cpu_pause();//Tell CPU now in the spin lock wait state
	                    }

	                    //Check the lock is released
	                    if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
	                        return;
	                    }
	                }
	            }

	            //The current process for the processor, but still in the executable state
	            ngx_sched_yield();
	        }

	    #else

	    #if (NGX_THREADS)

	    #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !

	    #endif

	    #endif

	    }

	typedef volatile int64_t Atomic;

	#define _spin_unlock_safe   _unlock_safe

	typedef struct {
	 union {
	  struct {
	    int32_t tid;
	    int32_t atomic32;
	  };
	  volatile int64_t atomic;
	 };
	} CACHE_ALIGNED SpinLock;

	static __inline__ int64_t _get_tid() {
	  static __thread int64_t tid = -1;
	  if _unlikely(tid == -1) {
	    tid = (int64_t)(syscall(__NR_gettid));
	  }
	  return tid;
	}

	static __inline__ int _try_lock_safe(SpinLock *lock) {
	  SpinLock lock_val = };
	  return lock->atomic == 0 && _atomic_cmp_set(&lock->atomic, 0, lock_val.atomic);
	}

	static __inline__ int _unlock_safe(SpinLock *lock) {
	  SpinLock lock_val = };
	  return _atomic_cmp_set(&lock->atomic, lock_val.atomic, 0);
	}

	static __inline__ void _spin_lock_safe(SpinLock *lock) {
	  int i, n;
	  SpinLock lock_val = };
	  for (; ;) {
	    if (lock->atomic == 0 && _atomic_cmp_set(&lock->atomic, 0, lock_val.atomic)) {
	      return;
	    }

	    for (n = 1; n < 1024; n <<= 1) {

	      for (i = 0; i < n; i++) {
	        __asm__(".byte 0xf3, 0x90");
	      }

	      if (lock->atomic == 0 && _atomic_cmp_set(&lock->atomic, 0, lock_val.atomic)) {
	        return;
	      }
	    }

	    sched_yield();
	  }
	}

	static __inline__ void _spin_lock(Atomic *lock) {
	  int i, n;
	  for (; ;) {
	    if (*lock == 0 && _atomic_cmp_set(lock, 0, 1)) {
	      return;
	    }

	    for (n = 1; n < 1024; n <<= 1) {

	      for (i = 0; i < n; i++) {
	        __asm__(".byte 0xf3, 0x90");
	      }

	      if (*lock == 0 && _atomic_cmp_set(lock, 0, 1)) {
	        return;
	      }
	    }

	    sched_yield();
	  }
	}