原子操作实现

Dear 丶 2022-08-05 10:27 160阅读 0赞

**原子操作实现**

**关于CAS等原子操作：**  
         在开始说无锁队列之前，我们需要知道一个很重要的技术就是CAS操作——Compare & Set，或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是CMPXCHG 汇编指令。有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。

这个操作用C语言来描述就是下面这个样子：  
看一看内存\*reg里的值是不是oldval，如果是的话，则对其赋值newval。

int compare\_and\_swap (int\* reg, int oldval, int newval)   
\{     
      int old\_reg\_val = \*reg;     
      if (old\_reg\_val == oldval)        
               \*reg = newval;     
      return old\_reg\_val;   
\}   
这个操作可以变种为返回bool值的形式（返回 bool值的好处在于，可以调用者知道有没有更新成功）：  
bool compare\_and\_swap (int \*accum, int \*dest, int newval)  
\{     
      if ( \*accum == \*dest )   
      \{         
           \*dest = newval;         
           return true;     
      \}     
      return false;   
\}

// 原子自增操作

type \_\_sync\_fetch\_and\_add (type \*ptr, type value)

// 原子比较和交换（设置）操作

type \_\_sync\_val\_compare\_and\_swap (type \*ptr, type oldval type newval)

bool \_\_sync\_bool\_compare\_and\_swap (type \*ptr, type oldval type newval)

// 原子赋值操作

type \_\_sync\_lock\_test\_and\_set (type \*ptr, type value)

使用这些原子性操作，编译的时候需要加-march=cpu-type

无锁队列实现

http://coolshell.cn/articles/8239. [html][]

**muduo上的一个实现：**

#ifndef MUDUO_BASE_ATOMIC_H
    #define MUDUO_BASE_ATOMIC_H
    
    #include <boost/noncopyable.hpp>
    #include <stdint.h>
    
    namespace muduo
    {
    
    namespace detail
    {
    template<typename T>
    class AtomicIntegerT : boost::noncopyable
    {
     public:
      AtomicIntegerT()
        : value_(0)
      {
      }
    
      // uncomment if you need copying and assignment
      //
      // AtomicIntegerT(const AtomicIntegerT& that)
      //   : value_(that.get())
      // {}
      //
      // AtomicIntegerT& operator=(const AtomicIntegerT& that)
      // {
      //   getAndSet(that.get());
      //   return *this;
      // }
    
      T get()
      {
        return __sync_val_compare_and_swap(&value_, 0, 0); //如果ptr所指向的内存中的数据等于oldval,则设置其为newval, 返回true。
      }
    
      T getAndAdd(T x)
      {
        return __sync_fetch_and_add(&value_, x); // 返回值为*value_, value_的值变为value_ + x.
      }
    
      T addAndGet(T x)
      {
        return getAndAdd(x) + x; 
      }
    
      T incrementAndGet()
      {
        return addAndGet(1);
      }
    
      T decrementAndGet()
      {
        return addAndGet(-1);
      }
    
      void add(T x)
      {
        getAndAdd(x);
      }
    
      void increment()
      {
        incrementAndGet();
      }
    
      void decrement()
      {
        decrementAndGet();
      }
    
      T getAndSet(T newValue)
      {
        return __sync_lock_test_and_set(&value_, newValue);  // 将*ptr设为value并返回*ptr操作之前的值。
      }
    
     private:
      volatile T value_;
    };
    }
    
    typedef detail::AtomicIntegerT<int32_t> AtomicInt32;
    typedef detail::AtomicIntegerT<int64_t> AtomicInt64;
    }
    
    #endif  // MUDUO_BASE_ATOMIC_H</span>

[html]: http://www.2cto.com/kf/qianduan/css/