（11）muduo_base库源码分析：原子性

1.为什么需要原子性操作

• x++;
  （1）从内存中读x的值到寄存器中，对寄存器加1，再把新值写回x所处的内存地址
  （2）我们希望x的值被2个线程加2次，最后等于12，但是却等于11
  
• 解决原子问题方法1：使用锁
  当一个线程进入这个区域的时间，另一个线程就不能访问的该区域的资源，必须等到另外一个线程unlock，方可进入，但会引起锁竞争问题

lock
x++
unlock

• 解决原子问题方法2：使用原子操作
  （1）将下面看成一个整体
  
  （2）gcc提供原子性操作
  下面的操作是原子的，也就是说是线程安全的；
  锁的开销比原子性开销大

// 原子自增操作，*ptr+value
type __sync_fetch_and_add (type *ptr, type value)


// 原子比较和交换（设置）操作，先比较，后交换(设置)
//若*ptr == oldval，则*ptr=newvl，并返回oldval
//返回bool类型，若*ptr == oldval，则返回为真，再设置；若比较失败，则返回false，也不会设置
type __sync_val_compare_and_swap (type *ptr, type oldval type newval)
bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval)

// 原子赋值操作，*ptr=value
type __sync_lock_test_and_set (type *ptr, type value)
//一般设置native，让系统自动检测本地cpu的类型
使用这些原子性操作，编译的时候需要加-march=cpu-type

2.Atomic.h代码分析

• Atomic.h代码分析

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#ifndef MUDUO_BASE_ATOMIC_H
#define MUDUO_BASE_ATOMIC_H

#include "muduo/base/noncopyable.h"

#include <stdint.h>

namespace muduo
{

namespace detail
{
template<typename T>//T表示传递进来的类型
class AtomicIntegerT : noncopyable //表示AtomicIntegerT类型是不可以拷贝的，就是将=运算符做成私有的
{
 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()
  {
    // in gcc >= 4.7: __atomic_load_n(&value_, __ATOMIC_SEQ_CST)
    //先比较在设置：若value==0，就将value的值设置为0，并返回value的值；若不相等，则直接返回value
    return __sync_val_compare_and_swap(&value_, 0, 0);
  }

  T getAndAdd(T x)
  {
    // in gcc >= 4.7: __atomic_fetch_add(&value_, x, __ATOMIC_SEQ_CST)
    //先获取再加，返回的是没有修改过的value的值，再加x
    return __sync_fetch_and_add(&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)
  {
    // in gcc >= 4.7: __atomic_exchange_n(&value, newValue, __ATOMIC_SEQ_CST)
    //返回原来的值，并设置其为新值
    return __sync_lock_test_and_set(&value_, newValue);
  }

 private:
  volatile T value_;
};
}  // namespace detail

//模板实例化
typedef detail::AtomicIntegerT<int32_t> AtomicInt32;//32bit的原子性整数类
typedef detail::AtomicIntegerT<int64_t> AtomicInt64;

}  // namespace muduo

#endif  // MUDUO_BASE_ATOMIC_H

• 测试代码目录：
  （1）11\jmuduo\muduo\base\tests\Atomic_unittest.cc 来自于muduo\base\tests\Atomic_unittest.cc
  （2）11\jmuduo\muduo\base\tests\CMakeLists.txt来来自10的Timestamp的研究
  （3）11\jmuduo\muduo\base\Atomic.h来自于muduo\base\Atomic.h
  

==============================11\jmuduo\muduo\base\tests\CMakeLists.txt=========================================
add_executable(timestamp_unittest Timestamp_unittest.cc)
target_link_libraries(timestamp_unittest muduo_base)

add_executable(atomic_unittest Atomic_unittest.cc)
#target_link_libraries(atomic_unittest muduo_base)##这个例子只提供了头文件，不链接muduo_base库也可以

• 编译和执行情况

位置参考：
jiwangreal@ubuntu:~/wangji/src/11/build/debug/bin$ ./atomic_unittest

结果啥都没有，因为assert都是真，所以没啥输出

3.如何实现无锁队列？

19：18

• 参考：

无锁队列的实现
https://coolshell.cn/articles/8239.html