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*) * ;
                 this->queue_count_ = queue_count;
                 shm_ = mmap(NULL, queue_size_, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS , -, );
                 memset(shm_, , queue_size_);
                 head_ = (unsigned long*)shm_;
                 tail_ = (unsigned long*)((char*)shm_ + sizeof(unsigned long));
                 queue_ = (void**)((char*)shm_ + sizeof(unsigned long) * );
         }

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

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

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

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

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

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

                         int ret = __sync_bool_compare_and_swap(tail_, tail, tail + );
                         if(ret) {
                                 *ap = *( queue_ + (tail % queue_count_));
                                 return ;
                         }
                 }
                 return -;
         }
 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. 多进程通信的一个关键点，就是在于共享内存的时候，要确保所有的地址都是多进程共享的。所以这里存的指针，如果是多进程环境下，也应该是从共享内存中分配的。