无锁CAS/无锁队列

高并发，读写十分频繁，会使用CAS

1 互斥锁 自旋锁 原子操作

锁住的代码耗时短：counter++操作，自旋锁有优势

锁住的代码耗时长：for_add操作，自旋锁无优势【因为在等待的时候消耗的CPU资源比较多，做的无用功比较多】

如何选择不同的锁？

共享区域的粒度：线程切换会耗时，如果粒度小，spinlock时间小于CPU线程切换时间损耗，则有优势

mutex     共享区域运行时间比较长（如果获取不到锁，会让出CPU）

spinlock  执行的语句少，非阻塞（获取不到锁，就一直检测）

atomic     简单的数字加减

2. 无锁队列

读写都十分频繁的高并发情况下，可以使用无锁队列。

CAS(compare and swap )，是原⼦操作的⼀种，可⽤于在多线程编程中实现不被打断的数据交换操作，从⽽避免多线程同时改写某⼀数据时由于执⾏顺序不确定性以及中断的不可预知性产⽣的数据不⼀致问题。该操作通过将内存中的值与指定数据进⾏⽐较，当数值⼀样时将内存中的数据替换为新的值。
伪代码：比对当前值和旧值，如果相等，说明数据未被其他线程改变，那么就把新值写入；否则不写入

bool CAS(int * pAddr, int nExpected, int nNew)
{
    if( *pAddr == nExpected)
    {
        *pAddr = nNew;
        return ture;
    }
    else
        return false;
}

CAS实现无锁队列： 

__sync_bool_compare_and_swap(type *ptr, type oldval, type newval,...)  原子操作

更新成功：返回true  更新失败：返回false

使用原子变量的编译：sudo g++ -o lockless_queue lockless_queue.cpp -lpthread -latomic -std=c++11

注意： 变量需要设置成易失性关键字volatile

template <typename ElemType>
class Queue
{
private:
  struct qnode<ElemType> *volatile _head = NULL;  // 随着pop后指向的位置是不一样的, head不是固定的
  struct qnode<ElemType> *volatile _tail = NULL;  // 变量设置成易失性关键字：每次都会从内存里读数据（而不是cache），更新了也会写到内存里


void push(const ElemType &e)  // 无CAS的push操作
  {
    struct qnode<ElemType> *p = new qnode<ElemType>;
    p->_data = e;
    p->_next = NULL;

    struct qnode<ElemType> *t = _tail; // 获取尾部

    t->_next = p; // 插到尾部

    _tail = p; // 更新尾部节点
  }

  void push2(const ElemType &e) // 有CAS的push操作
  {
    struct qnode<ElemType> *p = new qnode<ElemType>;
    // printf("push head:%p, p:%p\n", _head, p);
    p->_data = e;
    p->_next = NULL;

    struct qnode<ElemType> *t = _tail;
    struct qnode<ElemType> *old_t = _tail; 
    int count = 0;
    do
    {
      while (t->_next != NULL) // 非空的时候要去更新 t->_next
        t = t->_next;          // 找到最后的节点
      if (count++ >= 1)
      {
        printf("push count:%d, t->_next:%p\n", count, t->_next);
      }
    }while (!__sync_bool_compare_and_swap(&t->_next, NULL, p));// 将null换为p即是插入的节点
    
    __sync_bool_compare_and_swap(&_tail, old_t, p);// 将最后的节点_tail更换为p节点
  }

关于CAS：

• STL的所有容器都不是线程安全的
• ZeroMQ、disruptor中用到了无锁队列，一般不要自己去写CAS，因为会出现很多问题，最好使用别人写好的无锁队列
• CAS在多线程同时竞争时，效率并不会很高，如果mutex、自旋锁能够满足要求，就尽量不要使用CAS

CPU——cache——内存 ，每个CPU对应一个cache

使用CAS时，如果一个CPU修改了自己cache的内容，其他CPU的cache都要失效

Intel开发⼿册：
signal ensures that the processor has exclusive use of any shared memory while the signal is asserted

CAS的缺点：

• 循环时间长开销很大

CAS配合无限循环使用，如果CAS失败，会一直尝试，带给CPU很大的开销

• 只能保证一个变量的原子操作

当对一个变量执行操作时，可以使用 CAS 保证原子操作，但是对多个变量操作时，CAS 目前无法直接保证操作的原子性。但是可以通过以下两种办法来解决：1）使用互斥锁来保证原子性；2）将多个变量封装成对象，通过 AtomicReference 来保证原子性。

• ABA问题

CAS需要三步：1）从内存V中读取A；2）比较A值和目标值B；3）用原子操作将内存V中的A值修改为B值，试想如果在比较过程中，另外一个线程将内存V中的A修改成了C，又被修改回去，CAS会认为这段时间内存的值从未被修改过，这个问题叫做ABA问题。因此，使用CAS时需要注意ABA问题是否会影响并发程序的正确性，如果有影响，则传统的互斥同步可能会比原子更高效。