CAS无锁操作

https://coolshell.cn/articles/8239.html

主要讲的是《Implementing Lock-Free Queues》的论点，具体直接看论文最好。这里总结些要点。

CAS就是Compare And Swap。gcc可以调用：

__sync_bool_compare_and_swap

这段代码讲出无锁的两个关键手段：

EnQueue(x) //进队列
{
    //准备新加入的结点数据
    q = new record();
    q->value = x;
    q->next = NULL;
 
    do {
        p = tail; //取链表尾指针的快照
    } while( CAS(p->next, NULL, q) != TRUE); //如果没有把结点链在尾指针上，再试
 
    CAS(tail, p, q); //置尾结点
}

一个就是CAS，一个就是Retry-Loop。

然后，还有一个ABA问题，就是在被抢占之前和之后数据地址没变，但是数据内容可能变了。解决思路就是加一个额外的状态来记录（也可以用记数）。

 一个无锁队列的实现：

#include <sys/mman.h>
#include <string.h>
#include <iostream>

class CircleQueue {
public:
        CircleQueue(int queue_count) {
                this->queue_size_ = queue_count * sizeof(void*) + sizeof(unsigned long*) * 2;
                this->queue_count_ = queue_count;
                shm_ = mmap(NULL, queue_size_, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS , -1, 0);
                memset(shm_, 0, queue_size_);
                head_ = (unsigned long*)shm_;
                tail_ = (unsigned long*)((char*)shm_ + sizeof(unsigned long));
                queue_ = (void**)((char*)shm_ + sizeof(unsigned long) * 2);
        }

        ~CircleQueue() {
                munmap(shm_, queue_size_);
        }

        int PushOneThread(void* ap) {
                if((int)(*head_ - *tail_) >= queue_count_) {
                        return 1;//full
                }
                queue_[ *head_ % queue_count_ ] = ap;
                *head_ = *head_ + 1;
                return 0;
        }

        bool IsEmpty() {
                if(*head_ == *tail_) {
                        return true;
                }
                return false;
        }

        int PopOneThread(void** ap) {
                if(*head_ == *tail_) {
                        return 1;
                }

                if (ap == NULL) {
                        return -1;
                }
                *ap = *(queue_ + *tail_ % queue_count_);
                *tail_ = *tail_ + 1;
                return 0;
        }

        int PopMultiThread(void** ap, int retry) {
                *ap = NULL;
                for(int i = 0; i < retry; ++i) {
                        volatile unsigned long tail = *tail_;
                        if(*head_ == tail) {
                                return 1;
                        }

                        int ret = __sync_bool_compare_and_swap(tail_, tail, tail + 1);
                        if(ret) {
                                *ap = *( queue_ + (tail % queue_count_));
                                return 0;
                        }
                }
                return -1;
        }
private:
        unsigned long* head_;
        unsigned long* tail_;
        void** queue_;
        void* shm_;
        int queue_size_;
        int queue_count_;
};

这里的场景主要是一写多读。写的时候操作的是head，不需要加锁。读的时候，tail在改变的时候用上了CAS和retry-loop。 注意这里tail_只有在写的时候改变，而且只会往上加，所以不存在ABA问题。

p.s. 多进程通信的一个关键点，就是在于共享内存的时候，要确保所有的地址都是多进程共享的。所以这里存的指针，如果是多进程环境下，也应该是从共享内存中分配的。