并发容器之ConcurrentLinkedQueue详解与源码分析

最新推荐文章于 2024-03-18 11:09:28 发布

m0_60607895

最新推荐文章于 2024-03-18 11:09:28 发布

阅读量747

点赞数 19

分类专栏： 2024年程序员面试文章标签： java redis 开发语言

本文链接：https://blog.csdn.net/m0_60607895/article/details/136721712

版权

2024年程序员面试专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细解析了Java中的ConcurrentLinkedQueue的Node类结构，重点探讨了CAS操作在维护队列中的应用，以及offer和poll方法在单线程和多线程环境下的执行逻辑。

摘要由CSDN通过智能技术生成

Node

要想先学习ConcurrentLinkedQueue自然而然得先从它的节点类看起，明白它的底层数据结构。Node类的源码为：

private static class Node {

volatile E item;

volatile Node next;

…

}

Node节点主要包含了两个域：一个是数据域item，另一个是next指针，用于指向下一个节点从而构成链式队列。并且都是用volatile进行修饰的，以保证内存可见性（关于volatile可以看这篇文章）。另外ConcurrentLinkedQueue含有这样两个成员变量：

private transient volatile Node head;

private transient volatile Node tail;

说明ConcurrentLinkedQueue通过持有头尾指针进行管理队列。当我们调用无参构造器时，其源码为：

public ConcurrentLinkedQueue() {

head = tail = new Node(null);

}

head和tail指针会指向一个item域为null的节点，此时ConcurrentLinkedQueue状态如下图所示：

如图，head和tail指向同一个节点Node0，该节点item域为null，next域为null。

在这里插入图片描述

操作Node的几个CAS操作

在队列进行出队入队的时候免不了对节点需要进行操作，在多线程就很容易出现线程安全的问题。可以看出在处理器指令集能够支持CMPXCHG指令后，在java源码中涉及到并发处理都会使用CAS操作(关于CAS操作可以看这篇文章)，那么在ConcurrentLinkedQueue对Node的CAS操作有这样几个：

//更改Node中的数据域item

boolean casItem(E cmp, E val) {

return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);

}

//更改Node中的指针域next

void lazySetNext(Node val) {

UNSAFE.putOrderedObject(this, nextOffset, val);

}

//更改Node中的指针域next

boolean casNext(Node cmp, Node val) {

return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);

}

可以看出这些方法实际上是通过调用UNSAFE实例的方法，UNSAFE为sun.misc.Unsafe类，该类是hotspot底层方法，目前为止了解即可，知道CAS的操作归根结底是由该类提供就好。

offer方法

对一个队列来说，插入满足FIFO特性，插入元素总是在队列最末尾的地方进行插入，而取（移除）元素总是从队列的队头。所有要想能够彻底弄懂ConcurrentLinkedQueue自然而然是从offer方法和poll方法开始。那么为了能够理解offer方法，采用debug的方式来一行一行的看代码走。另外，在看多线程的代码时，可采用这样的思维方式：

单个线程offer

多个线程offer

部分线程offer，部分线程poll

----offer的速度快于poll

--------队列长度会越来越长，由于offer节点总是在对队列队尾，而poll节点总是在队列对头，也就是说offer线程和poll线程两者并无“交集”，也就是说两类线程间并不会相互影响，这种情况站在相对速率的角度来看，也就是一个"单线程offer"

----offer的速度慢于poll

--------poll的相对速率快于offer，也就是队头删的速度要快于队尾添加节点的速度，导致的结果就是队列长度会越来越短，而offer线程和poll线程就会出现“交集”，即那一时刻就可以称之为offer线程和poll线程同时操作的节点为 临界点 ，且在该节点offer线程和poll线程必定相互影响。根据在临界点时offer和poll发生的相对顺序又可从两个角度去思考：1. 执行顺序为offer–>poll–>offer，即表现为当offer线程在Node1后插入Node2时，此时poll线程已经将Node1删除，这种情况很显然需要在offer方法中考虑； 2.执行顺序可能为：poll–>offer–>poll，即表现为当poll线程准备删除的节点为null时（队列为空队列），此时offer线程插入一个节点使得队列变为非空队列

先看这么一段代码：

ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>();

queue.offer(1);

queue.offer(2);

创建一个ConcurrentLinkedQueue实例，先offer 1，然后再offer 2。offer的源码为：

public boolean offer(E e) {

checkNotNull(e); // 1

final Node newNode = new Node(e); // 2

for (Node t = tail, p = t;😉 { // 3

Node q = p.next; // 4

if (q == null) { // 5

// p is last node // 6

if (p.casNext(null, newNode)) { // 7

// Successful CAS is the linearization point //

// for e to become an element of this queue, //

// and for newNode to become “live”. //

if (p != t) // hop two nodes at a time // 8

casTail(t, newNode); // Failure is OK. // 9

return true; // 10

} //

// Lost CAS race to another thread; re-read next //

} //

else if (p == q) // 11

// We have fallen off list. If tail is unchanged, it //

// will also be off-list, in which case we need to //

// jump to head, from which all live nodes are always //

// reachable. Else the new tail is a better bet. //

p = (t != (t = tail)) ? t : head; // 12

else //

// Check for tail updates after two hops. //

p = (p != t && t != (t = tail)) ? t : q; // 13

}

单线程执行角度分析：

先从单线程执行的角度看起，分析offer 1的过程。第1行代码会对是否为null进行判断，为null的话就直接抛出空指针异常，第2行代码将e包装成一个Node类，第3行为for循环，只有初始化条件没有循环结束条件，这很符合CAS的“套路”，在循环体CAS操作成功会直接return返回，如果CAS操作失败的话就在for循环中不断重试直至成功。这里实例变量t被初始化为tail，p被初始化为t即tail。为了方便下面的理解，p被认为队列真正的尾节点，tail不一定指向对象真正的尾节点，因为在ConcurrentLinkedQueue中tail是被延迟更新的，具体原因我们慢慢来看。代码走到第3行的时候，t和p都分别指向初始化时创建的item域为null，next域为null的Node0。第4行变量q被赋值为null，第5行if判断为true，在第7行使用casNext将插入的Node设置成当前队列尾节点p的next节点，如果CAS操作失败，此次循环结束在下次循环中进行重试。CAS操作成功走到第8行，此时p==t，if判断为false，直接return true返回。如果成功插入1的话，此时ConcurrentLinkedQueue的状态如下图所示：

在这里插入图片描述

如图，此时队列的尾节点应该为Node1，而tail指向的节点依然还是Node0，因此可以说明tail是延迟更新的。那么我们继续来看offer 2的时候的情况，很显然此时第4行q指向的节点不为null了，而是指向Node1，第5行if判断为false，第11行if判断为false,代码会走到第13行。好了，再插入节点的时候我们会问自己这样一个问题？上面已经解释了tail并不是指向队列真正的尾节点，那么在插入节点的时候，我们是不是应该最开始做的就是找到队列当前的尾节点在哪里才能插入？那么第13行代码就是找出队列真正的尾节点。

定位队列真正的对尾节点

p = (p != t && t != (t = tail)) ? t : q;

我们来分析一下这行代码，如果这段代码在单线程环境执行时，很显然由于p==t，此时p会被赋值为q，而q等于Node<E> q = p.next，即Node1。在第一次循环中指针p指向了队列真正的队尾节点Node1，那么在下一次循环中第4行q指向的节点为null，那么在第5行中if判断为true,那么在第7行依然通过casNext方法设置p节点的next为当前新增的Node，接下来走到第8行，这个时候p!=t，第8行if判断为true，会通过casTail(t, newNode)将当前节点Node设置为队列的队尾节点,此时的队列状态示意图如下图所示：

在这里插入图片描述

tail指向的节点由Node0改变为Node2，这里的casTail失败不需要重试的原因是，offer代码中主要是通过p的next节点q(Node<E> q = p.next)决定后面的逻辑走向的，当casTail失败时状态示意图如下：

在这里插入图片描述

如图，如果这里casTail设置tail失败即tail还是指向Node0节点的话，无非就是多循环几次通过13行代码定位到队尾节点。

通过对单线程执行角度进行分析，我们可以了解到poll的执行逻辑为：

如果tail指向的节点的下一个节点（next域）为null的话，说明tail指向的节点即为队列真正的队尾节点，因此可以通过casNext插入当前待插入的节点，但此时tail并未变化
如果tail指向的节点的下一个节点（next域）不为null的话，说明tail指向的节点不是队列的真正队尾节点。通过q（Node<E> q = p.next）指针往前递进去找到队尾节点，然后通过casNext插入当前待插入的节点，并通过casTail方式更改tail。

我们回过头再来看p = (p != t && t != (t = tail)) ? t : q;这行代码在单线程中，这段代码永远不会将p赋值为t，那么这么写就不会有任何作用，那我们试着在多线程的情况下进行分析。

多线程执行角度分析

多个线程offer

很显然这么写另有深意，其实在多线程环境下这行代码很有意思的。 t != (t = tail)这个操作并非一个原子操作，有这样一种情况：

在这里插入图片描述

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

最后我们该如何学习？

1、看视频进行系统学习

这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。

另外，我自己也珍藏了好几套视频资料躺在网盘里，有需要的我也可以分享给你：

1年半经验，2本学历，Curd背景，竟给30K，我的美团Offer终于来了