原子操作

gcc提供的__sync_系列的built-in函数【线程安全并且原子性的操作，操作的时候都不用加锁】：

type __sync_fetch_and_add (type *ptr, type value, ...)
type __sync_fetch_and_sub (type *ptr, type value, ...)
type __sync_fetch_and_or (type *ptr, type value, ...)
type __sync_fetch_and_and (type *ptr, type value, ...)
type __sync_fetch_and_xor (type *ptr, type value, ...)
type __sync_fetch_and_nand (type *ptr, type value, ...) //{ tmp = *ptr; *ptr = ~tmp & value; return tmp; }
以上都是先返回*ptr的值，然后再将*ptr和value进行add/sub/or/and/xor/nand之后更新*ptr
以count = 4为例，调用__sync_fetch_and_add(&count,1)之后，返回值是4，count变成了5

type __sync_add_and_fetch (type *ptr, type value, ...)
type __sync_sub_and_fetch (type *ptr, type value, ...)
type __sync_or_and_fetch (type *ptr, type value, ...)
type __sync_and_and_fetch (type *ptr, type value, ...)
type __sync_xor_and_fetch (type *ptr, type value, ...)
type __sync_nand_and_fetch (type *ptr, type value, ...) //{ *ptr = ~*ptr & value; return *ptr; }
以上都是先将*ptr和value进行add/sub/or/and/xor/nand之后更新*ptr，然后返回*ptr的值
以count = 4为例，调用__sync_add_and_fetch(&count,1)之后，count的值为5，返回值是5

/*可以用将这个12个函数用宏定义重新定义以下，使其更加方便的使用*/
#define ATOMIC_ADD_F(ptr, value) (( __typeof__ (*( ptr ))) __sync_add_and_fetch(( ptr ), ( value )))
#define ATOMIC_SUB_F(ptr, value) (( __typeof__ (*( ptr ))) __sync_sub_and_fetch(( ptr ), ( value )))
#define ATOMIC_OR_F(ptr, value)  (( __typeof__ (*( ptr ))) __sync_or_and_fetch(( ptr ), ( value )))
#define ATOMIC_AND_F(ptr, value) (( __typeof__ (*( ptr ))) __sync_and_and_fetch(( ptr ), ( value )))
#define ATOMIC_XOR_F(ptr, value) (( __typeof__ (*( ptr ))) __sync_xor_and_fetch(( ptr ), ( value )))

#define ATOMIC_F_ADD(ptr, value) (( __typeof__ (*( ptr ))) __sync_fetch_and_add(( ptr ), ( value )))
#define ATOMIC_F_SUB(ptr, value) (( __typeof__ (*( ptr ))) __sync_fetch_and_sub(( ptr ), ( value )))
#define ATOMIC_F_OR(ptr, value)  (( __typeof__ (*( ptr ))) __sync_fetch_and_or(( ptr ), ( value )))
#define ATOMIC_F_AND(ptr, value) (( __typeof__ (*( ptr ))) __sync_fetch_and_and(( ptr ), ( value )))
#define ATOMIC_F_XOR(ptr, value) (( __typeof__ (*( ptr ))) __sync_fetch_and_xor(( ptr ), ( value )))

__typeof__(var) 是gcc对C语言的一个扩展保留字，用于声明变量类型,var可以是数据类型（int， char*，结构体..),也可以是变量表达式
__typeof__(int*) x; ----------->int *x; //这两者声明的变量x都是一样的，下面的也都一样，意义等同

__typeof__(int) a;  ----------->int a;

__typeof__(*x) y;   ----------->int y;

__typeof__(&a) b:   ----------->int *b;

__typeof__(__typeof__(int *)[4]) ------------> int  *z[4]';


这两个函数提供原子的比较和交换，如果*ptr == oldval,就将newval写入*ptr,
第一个函数在相等并写入的情况下返回true.第二个函数返回操作之前的值
bool __sync_bool_compare_and_swap (type*ptr, type oldval, type newval, ...)
type __sync_val_compare_and_swap (type *ptr, type oldval,  type newval, ...)


type __sync_lock_test_and_set (type *ptr, type value, ...) //将*ptr设为value并返回*ptr操作之前的值

void __sync_lock_release (type *ptr, ...) //将*ptr置0


memory barrier【内存栅】的三种类型：
    acquire barrier : 不允许将barrier之后的内存读取指令移到barrier之前（linux kernel中的wmb()）
    release barrier : 不允许将barrier之前的内存读取指令移到barrier之后 (linux kernel中的rmb())
    full barrier    : 以上两种barrier的合集(linux kernel中的mb())
 
__sync_synchronize (...) 发出一个full barrier 例：
 
    write1(somevalue1);
    write1(somevalue2);
    write1(somevalue3);
    __sync_synchronize();
    write1(somevalue4);
   
我们在最后一条语句之前加入一个memory barrier,强制cpu执行完前面的写入以后再执行后面的写内容

参考网址：http://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html