CAS原子锁 高效自旋无锁的正确用法

 "atomic_lock.h"

 #pragma once
 #ifndef _atomic_lock_h_include_
 #define _atomic_lock_h_include_

 #define spin_num (2048)

 #ifdef _MSC_VER

 #include <windows.h>

 #define cpu_pause()  __asm {pause}
 #define thread_yield()         Yield()

 __forceinline int compare_and_swap(long volatile *des, long out, long set)
 {
     InterlockedCompareExchange(des, set, out);
     return *des == set;
 }

 #endif

 #ifdef __GNUC__

 #include <sched.h>

 #define cpu_pause()  __asm__ ("pause")
 #define thread_yield()       sched_yield()

 #if defined(__INTEL_COMPILER) || (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1))
 #define USE_BUILTINS
 #endif

 static inline int compare_and_swap(volatile long* x, long oldval, long newval) {
 #ifdef USE_BUILTINS
     return    __sync_bool_compare_and_swap(x, oldval, newval);
 #elif defined(__i386__)
     char result;
     asm volatile ("lock; cmpxchgl %3, %0; setz %1" : "=m"(*x), "=q" (result) : "m" (*x), "r" (newval), "a" (oldval) : "memory");
     return result;
 #elif defined(__x86_64__)
     char result;
     asm volatile ("lock; cmpxchgq %3, %0; setz %1" : "=m"(*x), "=q" (result) : "m" (*x), "r" (newval), "a" (oldval) : "memory");
     return result;
 #else
 #error architecture not supported and gcc too old.
 #endif
 }

 #endif

 typedef struct {
     volatile long   lock;
 } app_atomic_lock_t;

 int app_atomic_trylock(app_atomic_lock_t* lt, long value);

 void app_atomic_lock(app_atomic_lock_t* lt, long value);

 void app_atomic_unlock(app_atomic_lock_t* lt, long value);
 #endif

"atomic_lock.c"

 #include "atomic_lock.h"

 int app_atomic_trylock(app_atomic_lock_t * lt, long value)
 {
      &&
          compare_and_swap(&lt-> }

 void app_atomic_lock(app_atomic_lock_t * lt, long value)
 {
     u_int n, i;

     for (;; ) {

          && compare_and_swap(&lt->, value)) {
             return;
         }
         ; n < spin_num; n <<= ) {

             ; i < n; i++) {
                 cpu_pause();
             }

              && compare_and_swap(&lt->, value)) {
                 return;
             }
         }

         thread_yield();
     }
 }

 void app_atomic_unlock(app_atomic_lock_t * lt, long value)
 {
     compare_and_swap(&lt->);
 }

#include "atomic_lock.h"

app_atomic_lock_t lock;
volatile int value;

void* th_fun(void *arg)
{
    int i;
    ; i < ; i++){

        app_atomic_lock(&);
        value++;
        app_atomic_unlock(&);
    }
    return NULL;
}

int main()
{
    ;

    pthread_t th1, th2;

    pthread_create(&th1, NULL, th_fun, NULL);
    pthread_create(&th2, NULL, th_fun, NULL);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);

    printf("%d\n", value);
    ;
}

cas在loop抢占的时候，会大量消耗cpu，在x86指令集下，可以用pause指令来减少loop的消耗。

cas锁在极高并发时候，会有非常大的帮助，相反，抢占时间过长，则千万不要用cas无锁。