C++的多线程技术系列讲解---1无锁队列背景讲解

无锁队列的背景

   无锁队列适用于多线程的操作任务，对于多任务系统，主要是线程池+任务队列实现调度。任务队列实现安全并发需要适用锁机制或者无锁队列，对于轻量级的任务使用无锁队列性能更好。

1、非原子操作的问题

struct Node{
    void *data;
    Node *next;
};

void Enqueue(Node *node){
    m_Tail->next = node;
    m_Tail = node;
}

Node* Dequeue(){
    Node * res = m_Head;
    m_Head = m_Head->next;
    return res;
}

入队与出队皆有两步操作，如果存在两个以上相同的线程同时进行写入或读取，便可能会出现在完成了第一步操作后，其他线程修改了Head或Tail指针，导致完全无法预料的结果。例如下列情况，两个线程同时写入，导致Tail指针失去与队列的链接，后加的节点从D之后就访问不到了。

线程A	线程B	队列实际情况
		队列 A->B
入队C tail->next = C		A->B->C head ：A Tail：B
	入队D tail->next = D	A->B->D head ：A Tail：B
	tail =D	A->B->D head ：A Tail：D
tail =C		A->B->D head ：A Tail：C

解决方法是在读写之前加锁，确保同一时间只有一个线程在进行读写，或是使用CPU提供的原子操作（atomic operation），一次性完成对Head或Tail指针的读写，实现无锁同步。

2、原子操作

在质子中子发现之前，人们认为原子就是世界上最基本的粒子了，原子一词便有了“不可分割”的含义。顾名思义，原子操作就是指不可分割的操作，CPU的一个线程在执行原子操作时，不会被其他线程中断或抢占。

典型的原子操作及示意代码如下：

• Load / Store： 读取与保存。
• Test and Set：针对bool变量，如果为true则返回true，如果为false，则将变量置为true并返回false。

bool TestAndSet(bool * flag){
    bool res = *flag;
    *flag = true;
    return res;
}

• Exchange：将指定位置的值设置为传入值，并返回其旧值。

template <typename T>
T Exchange(T* addr, const T& newVal){
    T oldVal = *addr;
    *addr = newVal;
    return oldVal;
}

• Compare And Swap（CAS）：将指定位置的值与期望值比较，如果相等则赋值为新值，如果不等则将期望值设置为自身。返回是否设置成功。

template <typename T>
bool CompareAndSwap(T* addr, T& expected, const T& desired){
    if(*addr == expected){
        *addr = desired;
        return true;
    }
    expected = *addr;
    return false;
}

这里使用最简单的i++操作来比较说明一下为什么需要原子操作，C++中一条i++语句，会生成三条汇编指令。

int i = 0;
i++;

mov         eax,dword ptr [i]   // 将i加载到eax寄存器
add         eax,1  // eax中的值加一
mov         dword ptr [i],eax  // 将eax中的值赋值到i的地址

如果有两个线程同时对一个变量i=0执行i++操作，最终结果很可能是1而不是2，因为多线程并行时，i的值会加载到不同的寄存器，然后分别对寄存器中的值加一并取出，导致落后的线程覆盖了领先线程的结果。这种现象被称为竞争条件（Race condition）。

3.使用CAS实现无锁队列

3.1 CAS图解

CAS，是Compare and Swap的简称，在这个机制中有三个核心的参数：

主内存中存放的共享变量的值：V（一般情况下这个V是内存的地址值，通过这个地址可以获得内存中的值）
工作内存中共享变量的副本值，也叫预期值：A
需要将共享变量更新到的最新值：B

如上图中，主存中保存V值，线程中要使用V值要先从主存中读取V值到线程的工作内存A中，然后计算后变成B值，最后再把B值写回到内存V值中。多个线程共用V值都是如此操作。CAS的核心是在将B值写入到V之前要比较A值和V值是否相同，如果不相同证明此时V值已经被其他线程改变，重新将V值赋给A，并重新计算得到B，如果相同，则将B值赋给V。

3.2 CAS代码实现

/*结构定义*/
#pragma once
#include <windows.h>
#include <windef.h>
#include <intrin.h>
#include <emmintrin.h>

using AtomicWord = intptr_t;

struct AtomicNode
{
    volatile AtomicWord _next;
    void* data;
};

class AtomicQueue
{
    volatile AtomicWord _tail;
    volatile AtomicWord _head;
public:
    AtomicQueue();
    ~AtomcQueue();
    void Enqueue(AtomicNode* node);
    AtomicNode* Dequeue();
}

/*封装CAS的原子操作*/
static inline AtomicWord AtomicExchangeExplicit(volatile AtomicWord* p, AtomicWord val)
{
    return (AtomicWord)_InterlockedExchange64((volatile long long*)p, (long long)val);
}

static inline bool AtomicCompareExchangeStrongExplicit(volatile AtomicWord* p, AtomicWord* oldval, AtomicWord newval)
{
    long long res = _InterlockedCompareExchange64((volatile long long*)p, (long long)newval, (long long)*oldval);
    if(res == *oldval)
        return true;
    
    *oldval = res;
    return false;
}

   void Enqueue(AtomicNode* node) {
        AtomicNode* prev;
        node->_next = 0;
        prev = (AtomicNode*)AtomicExchangeExplicit(&_tail, (AtomicWord)node);
        prev->_next = (AtomicWord)node;
    }

    AtomicNode* Dequeue() {
        AtomicNode* res, * next;
        void* data;
        AtomicWord head = _head;
        AtomicWord newHead;
        do
        {
            // 出队的时候最后剩下的是最后一次入队的节点
            res = (AtomicNode*)head;
            next = (AtomicNode*)res->_next;
            if (next == nullptr)
                return nullptr;
            data = next->data;
            newHead = (AtomicWord)next;
            //  比较_head指针是否是我们之前获取的，成功则设置newHead，失败则自旋
        } while (!AtomicCompareExchangeStrongExplicit(&_head, &head, newHead));

        res->data = data;
        return res;
    }

从原理上来说并不难理解，入队就是使用新的节点与原来的尾节点交换，出队就是使用CAS判断我们缓存的头节点是否与队列头节点相同（不同的话说明被其他线程修改了）。

C++编译器会为我们做许多优化，但某些时候这些优化会造成意外的结果。我们在出队时使用了循环判断

do{
    res = head;
    newHead = res->next;
  }
while(!CAS(_head, head, newHead));

也就是说我们一直在判断_head 是否等于head，而head最初也是等于_head的。编译器并不知道可能有另外的线程在修改_head的值，因此可能会将_head与head的比较优化掉，只从内存中读取一次_head的值存放进寄存器，随后便一直使用寄存器中的数据，使得我们的自旋等待失效。这便是常量优化。

常量优化的原因是寄存器的读写速度远高于内存，编译器会减少从内存读取数据的次数。而volatile关键字就是告诉编译器，不要对这个变量进行常量优化，每次都去内存中读取。