文章目录
1、CAS原子操作的基本原理
在说无锁队列之前，我们需要讲一下一个非常重要的技术——CAS操作。
有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。
假设现在有一个公共的整形变量a = 10；
现在有两个线程A和B，A线程需要将a的值改为20，B线程需要将a的值改为30
int a = 10;
线程A
a = 20;
内存中a的值 旧的预期值10 修改的新值20
线程B
a = 30;
内存中b的值 旧的预期值10 修改的新值30
首先线程A想要把a变量更改为20，所以旧的预期值a为10，修改的新值为20，但是在A线在提交更新之前，B线程抢先把a改为了30。此时A线程提交更新，发现内存中a(30)的值和旧的预期值()不一样，提交失败。
此时，如果加上while循环，A线程会再一次提交更新，如果运气不好，总是有线程在A线程更新提交之前，将a值更改，那么A线程就会一直不停的提交更新，知道成功为止。这一过程，我们称之为自旋。
从思想上来说，CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新。
CAS操作的代码实现：
int compare_and_swap (int* reg, int oldval, int newval)
{
int old_reg_val = *reg;
if (old_reg_val == oldval) {
*reg = newval;
}
return old_reg_val;
}
上述代码的意思就是看一看内存*reg里的值是不是oldval，如果是的话，则对其赋值newval。
我们可以看到，old_reg_val 总是返回，于是，我们可以在 compare_and_swap 操作之后对其进行测试，以查看它是否与 oldval相匹配，因为它可能有所不同，这意味着另一个并发线程已成功地竞争到 compare_and_swap 并成功将 reg 值从 oldval 更改为别的值了。
可以将其修改一下：
bool compare_and_swap (int *addr, int oldval, int newval)
{
if ( *addr != oldval ) {
return false;
}
*addr = newval;
return true;
}
这个操作可以变种为返回bool值的形式（返回 bool值的好处在于，可以调用者知道有没有更新成功）
2、无锁队列的链表实现
2.1 结点以及无锁队列的框架
因为实现无锁队列需要用到原子性操作库(atomic)，所以需要引入这个头文件 #include
struct ListNode
{
int _val;
atomic<ListNode*> _next;//指向下一个结点的指针
ListNode(int val = 0)
:_val(val)
, _next(nullptr)
{}
};
class NoLockList
{
private:
atomic<ListNode*> _head;
atomic<ListNode*> _tail;
public:
NoLockList();
~NoLockList();
void NoLockListInit();//初始化
void EnQueue(int val);//入队列
int DeQueue();//出队列
int length();//获取长度
void Print();//打印
};
我们规定_head == _tail && _head->next == nullptr的时候，才表示队列为空。也就是说，我们需要定义一个哨兵结点。
2.2 初始化——NoLockListInit
初始化一个队列的代码很简，初始化一个哨兵结点（注：在链表操作中，使用一个哨兵结点，可以少掉很多边界条件的判断），如下所示：
void NoLockList::NoLockListInit()
{
_head = _tail = new ListNode();
}
2.3 入队列——EnQueue
先来看一下进队列用CAS(C++中为compare_exchange_weak)实现的方式，基本上来说就是链表的两步操作：
第一步，把_tail指针的_next指向要加入的结点。 tail->next = Node；
第二步，把tail指针移到队尾。 _tail = Node;
void NoLockList::EnQueue(int val)
{
//准备加入的新结点
ListNode* Node = new ListNode(val);
ListNode* tail = nullptr;
ListNode* tail_next = nullptr;
do
{
tail = _tail;//去链表尾指针的快照
tail_next = tail->_next;//理应为nullptr，但可能被其他线程抢先插入数据
} while (tail->_next.compare_exchange_weak(tail_next, Node) != true);
//wihle注释：如果没有吧Node新结点链在链表的尾部，就重复去尝试(自旋过程)
//更新_tail指针
_tail.compare_exchange_weak(tail, Node);
}
我们可以看到，程序中的那个 do-while 的中的 CAS 操作：如果 tail->_next 是 nullptr，那么，把新结点 Node 加到队尾。如果不成功，则重新再来一次！
就是说，很有可能我在准备在队列尾加入结点时，别的线程已经加成功了，于是_tail指针就变了，于是我的compare_exchange_weak返回了false，于是程序再试，直到试成功为止。这个很像我们的抢电话热线的不停重播的情况。
但是你会看到，为什么我们的“置尾结点”的操作不判断是否成功，因为：
- 如果有一个线程T1，它的while中的compare_exchange_weak如果成功的话，那么其它所有的随后线程的compare_exchange_weak都会失败，然后就会再循环
- 此时，如果T1 线程还没有更新_tail指针，其它的线程继续失败，因为_tail->next不是nullptr了。
- 直到T1线程更新完 _tail 指针，于是其它的线程中的某个线程就可以得到新的 _tail 指针，继续往下走了。
- 所以，只要线程能从while 循环中退出来，意味着，它已经“独占”了，tail 指针必然可以被更新。
里有一个潜在的问题——如果T1线程在用compare_exchange_weak更新_tail指针的之前，线程停掉或是挂掉了，那么其它线程就进入死循环了。下面是改良版的EnQueue()
void NoLockList::EnQueue(int val)
{
ListNode* Node = new ListNode(val);
ListNode* tail = nullptr;
ListNode* tail_next = nullptr;
tail = _tail;
tail_next = tail->_next;
while (true)
{
do
{
while (tail->_next.load() != nullptr)
{
tail = tail->_next;
tail_next = tail->_next;
}
} while (tail->_next.compare_exchange_weak(tail_next, Node) != true);//如果没把结点链在尾部，再尝试
}
//更新_tail指针
_tail.compare_exchange_weak(tail, Node);
}
我们让每个线程都去更新自己的链表尾，但这是很耗性能的一件事。如果有一个线程在不断的EnQueue。会导致其他线程都会去更新自己为链表尾。这些线程耗费大量时间，却在做同一件事。
所以为了节省时间，我们应该尽量避免这样的事。
因为_tail指针是所有线程都共享的，只要有一个线程更改了_tail指针，其他的线程都知道，所以，我们进行如下改进：
void NoLockList::EnQueue(int val)
{
ListNode* Node = new ListNode(val);
ListNode* tail = nullptr;
ListNode* tail_next = nullptr;
while (true)
{
tail = _tail;//每次都拿队列中最新的tail
tail_next = tail->_next;
if (tail != _tail) continue;//说明尾指针被移动，需要重新获取尾指针
if (tail_next != nullptr)
{
//说明已经有新的结点插入，但是还没来得及修改_tail，需要修正_tail。但此时_tail也可能已经被其他线程修正
_tail.compare_exchange_weak(tail, tail_next);
continue;
}
//代码执行到这里，tail_next 一定为nullptr
if (tail->_next.compare_exchange_weak(tail_next, Node) == true)
{
break;
}
}
//置尾结点
//成功，表示这次插入中，没有其他线程插入，
//失败，表示其他线程在本线程修正_tail之前已经插入了数据，并且已经修正了_tail
_tail.compare_exchange_weak(tail, Node);
}
2.4 出队列——DeQueue
nt NoLockList::DeQueue()
{
ListNode* head = nullptr;
do
{
head = _head;
if (head->_next.load() == nullptr)
{
return -1;
}
} while(_head.compare_exchange_weak(head, head->_next) != true);
return head->_next.load()->_val;
}
上述代码还存在一个问题：
在判断 head->_next == nullptr时，另外一个EnQueue操作做了一半，此时的 head->_next 不为 nullptr了，但是 _tail 指针还差最后一步，没有更新到新加的结点，这个时候就会出现，在 EnQueue 并没有完成的时候， DeQueue 已经把新增加的结点给取走了，此时，队列为空，但是，_head 与 _tail 并没有指向同一个结点。
虽然，EnQueue的函数会把 _tail 指针置对，但是，这种情况可能还是会导致一些并发问题，所以，严谨来说，我们需要避免这种情况。于是，我们需要加入更多的判断条件，还确保这个问题。下面是相关的改进代码：
int NoLockList::DeQueue()
{
ListNode* tail = nullptr;
ListNode* head = nullptr;
ListNode* head_next = nullptr;
int val = -1;
while (true)
{
tail = _tail;
head = _head;
head_next = head->_next;
//_head已经别其他线程移动，需要重新修正_head
if (head != _head)continue;
//空队列
if (head == tail && head_next == nullptr)
{
return -1;
}
//表示最开始本来为空队列，但是被其他线程插入了数据，但_tail还未修正
if (head == tail && head_next != nullptr)
{
_tail.compare_exchange_weak(tail, head_next);
continue;
}
//移动_head成功，取数据
if (_head.compare_exchange_weak(head, head_next) == true)
{
val = head_next->_val;
break;
}
}
delete head;
return val;
}
3、整体代码与测试
NoLockList.h
#pragma once
#include<atomic>
#include<iostream>
#include<thread>
#include<vector>
#include<Windows.h>
using namespace std;
struct ListNode
{
int _val;
atomic<ListNode*> _next;
ListNode(int val = 0)
:_val(val)
, _next(nullptr)
{}
};
class NoLockList
{
private:
atomic<ListNode*> _head;
atomic<ListNode*> _tail;
public:
NoLockList();
~NoLockList();
void NoLockListInit();//初始化
void EnQueue(int val);//入队列
int DeQueue();//出队列
int length();//获取长度
void Print();//打印
};
NoLockList.cpp
#include"NoLockList.h"
NoLockList::NoLockList()
{
NoLockListInit();
}
NoLockList::~NoLockList()
{
}
void NoLockList::NoLockListInit()
{
_head = _tail = new ListNode();
}
void NoLockList::EnQueue(int val)
{
ListNode* Node = new ListNode(val);
ListNode* tail = nullptr;
ListNode* tail_next = nullptr;
while (true)
{
tail = _tail;//每次都拿队列中最新的tail
tail_next = tail->_next;
if (tail != _tail) continue;//说明尾指针被移动，需要重新获取尾指针
if (tail_next != nullptr)
{
//说明已经有新的结点插入，但是还没来得及修改_tail，需要修正_tail。但此时_tail也可能已经被其他线程修正
_tail.compare_exchange_weak(tail, tail_next);
continue;
}
//代码执行到这里，tail_next 一定为nullptr
if (tail->_next.compare_exchange_weak(tail_next, Node) == true)
{
break;
}
}
//置尾结点
//成功，表示这次插入中，没有其他线程插入，
//失败，表示其他线程在本线程修正_tail之前已经插入了数据，并且已经修正了_tail
_tail.compare_exchange_weak(tail, Node);
}
int NoLockList::DeQueue()
{
ListNode* tail = nullptr;
ListNode* head = nullptr;
ListNode* head_next = nullptr;
int val = -1;
while (true)
{
tail = _tail;
head = _head;
head_next = head->_next;
//_head已经别其他线程移动，需要重新修正_head
if (head != _head)continue;
//空队列
if (head == tail && head_next == nullptr)
{
return -1;
}
//表示最开始本来为空队列，但是被其他线程插入了数据，但_tail还未修正
if (head == tail && head_next != nullptr)
{
_tail.compare_exchange_weak(tail, head_next);
continue;
}
//移动_head成功，取数据
if (_head.compare_exchange_weak(head, head_next) == true)
{
val = head_next->_val;
break;
}
}
delete head;
return val;
}
int NoLockList::length()
{
if (_head.load() == _tail.load())
{
return 0;
}
int len = 0;
ListNode* cur = _head;
while (cur->_next.load() != nullptr)
{
cur = cur->_next;
len++;
}
return len;
}
void NoLockList::Print()
{
if (_head.load() == _tail.load())
{
return;
}
ListNode* cur = _head.load()->_next;
while (cur != nullptr)
{
cout << cur->_val << " ";
Sleep(100);
cur = cur->_next;
}
cout << endl;
}
main.cpp
#include"NoLockList.h"
NoLockList list;
void ThreadFunc()
{
for (int i = 0; i < 50000; ++i)
{
list.EnQueue(i);
}
}
int main()
{
vector<thread> threads;
//5个线程同时EnQueue，每个线程的数据量为5w
for (int i = 0; i < 5; ++i)
{
threads.push_back(thread(ThreadFunc));
}
for (auto& it : threads)
{
it.join();
}
Sleep(1000);
cout << list.length() << endl;
return 0;
}
测试：
同时让5个线程去EnQueue，每个线程EnQueue5万个数据，如果最终的长度为25万，则表示这个无锁队列的EnQueue至少是成功的
结果正如期待的那样
920
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
