实现无锁的栈与队列(4)

现在我们来尝试解决前一篇文章提到的问题。

(一)

首先是内存释放的问题。

这个问题乍看起来很棘手：我们现在要访问一段内存，但却不知道这段内存是否还合法，是否已被释放。怎么办呢？很直接的一个想法是，看看有没别的方式可以检查该内存是否还合法，这个想法很单纯，但从前面几篇文章的讨论我们得知，任何时候直接去碰队列上的节点都是不安全的，当前线程永远不知道下一秒后会发生了什么事情，这就是为什么 lock free queue 需要引入一个 dummy 头结点的原因。

既然这样，那么我们能不能干脆简单点，直接就不允许释放链表的节点呢？

这个方案确实是最直接易用的，所付出的代价也最小，无非就是多费点内存，空间换效率，太划算了，boost 的 lock free queue 就采用了这种方法。

(1) 创建队列的时候，分配好全部的内存，比如说，2048 个节点。

(2) 重复实现一套无锁分配节点的方法。

其中第二条看起来有些为难，这不正是我们现在所要解决的问题吗？事实上这不大一样，在这里我们不需要再分配内部节点！因此，我们不需要担心内存回收的问题！只要处理好 aba 问题就行了！

struct Node
{
    Node* next;   // 用于在 lock free queue 中指向下一个指点
    Node* next2;  // 指向内部队列
    void* data;
};

Node g_FreeList[N];
Node* head;

void Init()
{
     g_FreeList = (Node*)malloc(sizeof(Node)*N);
     for (int i = 0; i < N -1; ++i)
     {
          g_FreeList[i].next2 = &g_FreeList[i+1];
      }
      
      g_FreeList[N-1].next2 = NULL;
}

Node* AllocNode()
{
     Node* old_head;
     do
     {
        old_head = head;
        if (old_head == NULL) return NULL;
        
        // 下面的一行仍有aba问题，后面再解决。
        if (CAS(&head, old_head, old_head->next2))
            break;
       }  while(1);
   
      return old_head;
 }

void ReleaseNode(Node* node)
{
     assert(node); // more advance check is necessary
     Node* old_head;
     do
     {
         old_head = head;
         node->next2 = old_head;
         if (CAS(&head, old_head, node))
             break;
      } while( 1);
}   

(二)

现在我们来看看  ABA 问题，回过头仔细观察一下 ABA 问题， 它的起因简单来说就在于 dequeue 的时候，无法确认 head 是否还是当初的 head, 也无法确认它的内容是否已经发生变化，因此无法更新当前的头结点指针。所以解法最直观的无外乎两个：

1) 在当前线程还在操作该节点时，不允许别的线程释放这个节点。

2) 给节点做标志，使得每个插入的节点有一个唯一的标记，这样，就能检测当前的节点是否已发生变化。

其中第一种做法在 C/C++ 中不容易做到，它们在语言层面上没有 GC, 对内存的操作都得靠程序员自己来把控，使得在处理资源的回收时，虽然更灵活，但也更不容易实现一些诸如自动回收这样的高级功能，不过这难不倒聪明人，2004 年时候，Maged.M.Machel(对，又是他), 在 IEEE 的期刊 Transactions on Parallel and Distributed Systems 上发一发表了一篇论文：Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects

该论文引入一个叫作 hazard pointer 的东西来处理 ABA 问题，关于 Hazard pointer 的介绍可以参考一下 wiki 中的条目。简而言之，hazard pointer 是实现了一种 reference 的机制，使得链表的节点如果还有线程在读，就不允许该节点被释放，这个方法实现起来有很多的细节要处理，并不是件容易做的事情，维基百科的附录里面介绍了好几种不同的人的实现方案，有兴趣的读者可以自行去研究研究。我在前一篇博客里提到过的 Christian Hergert 也在他的博客中介绍了他自己的 hazard pointer 的实现，代码放到了 github上，有兴趣的读者可以去看看。

阻止内存过早被释放这个做法不是件容易的事情，但如果做到了，就连我们上面讨论的内存访问的问题都一并解决了。Memory reclamation 是无锁算法里最棘手的两个问题之一了，Hazard Pointer 在这个难题上是个很完美的解决方案。但是 Hazard Pointer 来头太大，也太麻烦了，有没更轻量一点的方法呢？现在我们来看看第二种解法。为了说明第二种方法，我们来回顾一下 lock free queue 中 dequeue 的操作。

gpointer queue_dequeue(Queue *q)
    {
        Node *node, *tail, *next;

        while (TRUE) {
            head = q->head;
            tail = q->tail;
            next = head->next;
            if (head != q->head)
                continue;

            if (next == NULL)
                return NULL; // Empty

            if (head == tail) {
                CAS(&q->tail, tail, next);
                continue;
            }

            data = next->data;
            if (CAS(&q->head, head, next))
                break;
        }

        g_slice_free(Node, head); // This isn't safe
        return data;
    }

所有的问题归结起来，就在于第 21 行进行 cas 操作时，head 虽然还是 head，但 head->next 已经发生了变化。那么，我们应该怎样来识别这些变化呢？从本质上来说，既然 head 已经发生了变化，那接下来的 CAS 就应该要失败才是正确的行为。ABA 问题的根源就在于该失败的 CAS 操作没有失败，所以，我们现在的目标就是要纠正 CAS 的这个错误行为，让它在该失败的时候就彻底的失败。

回头来分析一下 cas 操作：

bool cas(type*ptr, type old, type new)

这个函数纯粹只是比较一下 ptr 与 old 的值，然后决定下一步的操作：如果 *ptr == old，就 *ptr = new，否则什么也不做(暂且这样理解)。

在我们的场景下，我们希望在 aba 问题出现了的时候，cas 能够失败。为了做到这点，我们自然希望 *ptr != old，但 aba 问题出现时，*ptr 是等于 old 的，因此我们在进行 cas 时不应该只比较 *ptr == old, 而应该想办法在 *ptr 中加入些不同的东西来加以区别，比如说再多比较几个字节，再决定是否更新 *ptr: 我们需要 cas 能比较的字节数要大于字长 (sizeof(void*))，这个要求显然是需要 cpu 的支持的。因此，我们现在讨论的这个解法并不具备普遍性，是要依赖硬件的。这大概也是为什么 Maged.M.Machel 花了大心思是去研究出 hazard pointer 的原因。好消息是，x86 平台上较新的 cpu 都是支持 double wide cas 的，也就是通常指的 CAS2，具体来说，就是支持cmpxchg8b, cmpxchg16b 这两条指令。

有了 CAS2 的支持，我们就可以对指向指向节点的指针加一个 tag 作为标记。

union DoublePointer
{
    void* vals[2];
    atomic_longlong val;
};

DoublePointer 包含了指向结点的指针，以及一个 tag，每次插入一个节点时，都用一个 DoublePointer 来指向这个新插入的结点，每个 DoublePointer 中包含了唯一的标记符，每次插入新结点或取出结点，都用 CAS2 来更新double pointer，从而就做到区别对待每一个新插入的结点，从根本上去除了 ABA 问题。语言上比较难说得清楚，还好可以用代码来说话，有兴趣取的读者可以看看我放在 github 上的代码，在 x86-64/32 上都进行了一定的压力测试，应该是没问题的(人艰不拆)。

 https://github.com/kmalloc/back-end-facility/blob/master/misc/LockFreeList.h

后话

好了，写 lock free queue 的目标到此算是基本完成了，花了一个多月的时间，一开始先是读了很多的文章，从无到有，算是在内存模型，cpu 结构方面有了些前所未有的了解，不过就算这样，真正写起来还是比想像中的困难太多了，尤其是 debug 的过程，刚开始时遇到问题简直束手无策，事实证明，思路清晰才是解决问题的根本方法，不能一发现问题就挂 gdb，那是没用的，特别是多线程的情况下，必须一点一点的分析代码，认真推敲，查找漏洞，挂gdb 应该只做验证之用，打 Log 其实更好了。四篇文章写下来，lock free queue 的实现过程基本是个重造轮子的过程，说到通用性可靠性那是没法和 boost 相比的，性能的话，也不一定比得上，唯一值得安慰的地方，就是它们是我的亲儿子了T_T.