原子操作



原子操作

在多线程编程中，访问同一个变量时需要利用锁来限制同一个时刻只有一个线程访问，否则会遇到未知的错误，最常用的锁有信号量、线程锁。系统也提供了一些原子操作来实现多个线程对同个变量的访问。它们的性能参照另外篇文章锁性能，从该文章中可知。原子操作比锁性能高，下面介绍系统所自带的几种原子操作

头文件atomic.h

typedef struct { 
    int counter; 
} atomic_t;

初始化值为i
#define ATOMIC_INIT(i)  { (i) }

原子读
static inline int atomic_read(const atomic_t *v)
{
        return v->counter;
}

原子设置值
static inline void atomic_set(atomic_t *v, int i)
{
        v->counter = i;
}

相加
static inline void atomic_add(int i, atomic_t *v)
{
        asm volatile(LOCK_PREFIX "addl %1,%0"
                     : "=m" (v->counter)
                     : "ir" (i), "m" (v->counter));
}

减去
static inline void atomic_sub(int i, atomic_t *v)
{
        asm volatile(LOCK_PREFIX "subl %1,%0"
                     : "=m" (v->counter)
                     : "ir" (i), "m" (v->counter));
}

测试两个变量是否相等，相等则返回0，不等返回-1
static inline int atomic_sub_and_test(int i, atomic_t *v)
{
        unsigned char c;

        asm volatile(LOCK_PREFIX "subl %2,%0; sete %1"
                     : "=m" (v->counter), "=qm" (c)
                     : "ir" (i), "m" (v->counter) : "memory");
        return c;
}

自增1
static inline void atomic_inc(atomic_t *v)
{
        asm volatile(LOCK_PREFIX "incl %0"
                     : "=m" (v->counter)
                     : "m" (v->counter));
}

递减1
static inline void atomic_dec(atomic_t *v)
{
        asm volatile(LOCK_PREFIX "decl %0"
                     : "=m" (v->counter)
                     : "m" (v->counter));
}

测试是否等于1，等于则返回0，不等于返回-1
static inline int atomic_dec_and_test(atomic_t *v)
{
        unsigned char c;

        asm volatile(LOCK_PREFIX "decl %0; sete %1"
                     : "=m" (v->counter), "=qm" (c)
                     : "m" (v->counter) : "memory");
        return c != 0;
}

测试变量是否等于-1，等于则返回0，不等于返回-1
static inline int atomic_inc_and_test(atomic_t *v)
{
        unsigned char c;

        asm volatile(LOCK_PREFIX "incl %0; sete %1"
                     : "=m" (v->counter), "=qm" (c)
                     : "m" (v->counter) : "memory");
        return c != 0;
}

相加，测试结果是否为负，负数返回0，非负返回-1
static inline int atomic_add_negative(int i, atomic_t *v)
{
        unsigned char c;

        asm volatile(LOCK_PREFIX "addl %2,%0; sets %1"
                     : "=m" (v->counter), "=qm" (c)
                     : "ir" (i), "m" (v->counter) : "memory");
        return c;
}

相加，并返回结果
static inline int atomic_add_return(int i, atomic_t *v)
{
        int __i = i;
        asm volatile(LOCK_PREFIX "xaddl %0, %1"
                     : "+r" (i), "+m" (v->counter)
                     : : "memory");
        return i + __i;
}

相减并返回结果
static inline int atomic_sub_return(int i, atomic_t *v)
{
        return atomic_add_return(-i, v);
}

宏定义
#define atomic_inc_return(v)  (atomic_add_return(1, v))
#define atomic_dec_return(v)  (atomic_sub_return(1, v))

如果v不等于u则v加上a，返回非0.否则返回0
static inline int atomic_add_unless(atomic_t *v, int a, int u)
{
        int c, old;
        c = atomic_read(v);
        for (;;) {
                if (unlikely(c == (u)))
                        break;
                old = atomic_cmpxchg((v), c, c + (a));
                if (likely(old == c))
                        break;
                c = old;
        }
        return c != (u);
}

#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)

对短整形变量进行递增1，并返回结果
static inline short int atomic_inc_short(short int *v)
{
        asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v));
        return *v;
}

对两个无符号长整形进行或操作，并返回结果
static inline void atomic_or_long(unsigned long *v1, unsigned long v2)
{
        asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2));
}