12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue!

并发编程系列之并发容器:ConcurrentLinkedQueue 前言 上节我们介绍了线程安全的HashMap,今天我们再来介绍一个线程安全的并发容器:ConcurrentLinkedQueue,它是一个线程安全的队列,在Java中如果要实现一个线程安全的队列由2种方式:一个是使用阻塞算法的队列,用一个锁(入队和出队列共享同一把锁)或者两个锁(入队和出队各持一把锁)来实现,另一个是使用非阻塞的CAS方式来实现,今天我们我们就来一起看看如何使用非阻塞方式实现ConcurrentLinkedQueue,OK,让我们扬帆起航,开始今天的并发之旅吧。 什么是Concur. 阅读详情

数据结构

ConcurrentLinkedQueue从名称上来看就能够知道,它支持并发、由链表实现的队列

image.png

通过源码,我们可以看到**ConcurrentLinkedQueue使用字段记录首尾节点、并且节点的实现是单向链表**

并且这些关键字段都被volatile修饰,在读场景下使用volatile保证可见性,不用“加锁”

还有一些其他字段,比如使用CAS的Unsafe和一些偏移量信息等,这里就不一一列举

  public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
          implements Queue<E>, java.io.Serializable {    
  
      private static class Node<E> {
          //记录数据
          volatile E item;
          //后继节点
          volatile Node<E> next;
      }
      //首节点
      private transient volatile Node<E> head;
      //尾节点
      private transient volatile Node<E> tail;
  }   

在初始化时,首尾节点会同时指向一个存储数据为空的节点

      public ConcurrentLinkedQueue() {
          head = tail = new Node<E>(null);
      }

设计思想

延迟更新首尾节点

在查看实现原理前,我们先来说说ConcurrentLinkedQueue的设计思想,否则实现原理可能会看不懂

ConcurrentLinkedQueue写场景中采用乐观锁的思想,使用CAS+失败重试来保证操作的原子性

为了避免CAS开销过大,ConcurrentLinkedQueue采用延迟更新首尾节点的思想,来减少CAS次数

也就是说ConcurrentLinkedQueue中的首尾节点并不一定是最新的首尾节点

哨兵节点

ConcurrentLinkedQueue的设计中使用哨兵节点

什么是哨兵节点?

哨兵节点又称虚拟节点,哨兵节点常使用在链表这种数据结构中

单向链表中如果要添加或者删除某个节点时,一定要获得这个节点的前驱节点再去进行操作

当操作的是第一个节点时,如果在第一个节点前面加个虚拟节点(哨兵节点),那么就不用特殊处理

换而言之使用哨兵节点可以减少代码复杂度,相信刷过链表相关算法的同学深有体会

哨兵节点还能够在只有一个节点时减少并发冲突

这一特点可能要看完后续实现和流程图才能理解

源码实现

ConcurrentLinkedQueue主要的操作是入队、出队,我们使用offer和poll来对其进行分析

offer

在分析源码前,先来说明一些复杂变量的作用

t记录尾节点tail

p用于循环遍历的节点,当p节点为真正尾节点时才允许添加新节点

q 用于记录p的后继节点

在入队时分三种情况:

  1. 当p的后继节点为空时(p为真正尾节点),尝试CAS增加新节点,成功后尝试更新尾节点tail
  2. 当p等于p的后继节点时(p的next指向自己,说明构建成哨兵节点,出队poll时可能构造哨兵节点);此时判断尾节点是否被修改过,如果尾节点被修改过就定位到尾节点,如果未被修改过(使用next无法继续遍历),只能定位到头节点
  3. 其他情况时,说明此时的p并不是真正的尾节点,需要定位到真正尾节点;此时如果p不是原来的尾节点并且尾节点被修改过,那就定位到尾节点,否则定位到后继节点继续遍历

第二、三种情况的代码观赏性很好但是可读性不好,可以将总结的情况与源码分析一起观看,如果还是不理解后续有流程图方便理解

      public boolean offer(E e) {
          //检查空指针
          checkNotNull(e);
          //构建新节点
          final Node<E> newNode = new Node<E>(e);
          //失败重试的循环
          //t:当前记录的尾节点
          //p:真正的尾节点
          //q:p的后继节点
          for (Node<E> t = tail, p = t;;) {
              Node<E> q = p.next;
              //情况1:p的后继节点为空,说明当前p就是真正尾节点
              if (q == null) {
                  //尝试CAS修改p的后继节点为新节点
                  //如果p的next是null 则替换成新节点newNode
                  //失败则说明其他线程cas添加节点成功,继续循环;成功则判断是否更新尾节点tail
                  if (p.casNext(null, newNode)) {
                      //如果p不等于t 说明此时的尾节点不是真正的尾节点
                      //尝试CAS:如果当前尾节点是t,那么就将新节点设置成尾节点
                      if (p != t) 
                          casTail(t, newNode);  
                      return true;
                  }
                  
              }
              //情况2:p等于p的后继节点(p指向自己)
              else if (p == q)
                  //t:旧的尾节点
                  //(t = tail):新的尾节点
                  //t != (t = tail): 说明尾节点被修改过,p等于新的尾节点;未被修改过,p等于头节点
                  p = (t != (t = tail)) ? t : head;
              
              //情况3:此时p不是真正尾节点,需要去定位真正尾节点
              else
                  //p!=t:p不再是原来的尾节点
                  //t != (t = tail):尾节点被修改过
                  //p不再是原来的尾节点 并且 尾节点被修改过 就让p等于修改过的尾节点;否则让p等于它的后继节点q
                  p = (p != t && t != (t = tail)) ? t : q;
          }
      }
poll

如果理解入队offer中的变量,那么出队poll也好理解,其中p和q都是类似的

h记录头节点head

p用于循环遍历的节点,当p节点为真正头节点时才允许出队

q 用于记录p的后继节点

出队的情况分为四种

  1. 当p为真正头节点时,CAS将数据设置为空,然后判断head是否为真正头节点,不是则更新头节点,然后将原来的头节点next指向它自己构建成哨兵节点
  2. 当p的后继节点为空时,说明队列为空,尝试CAS将头节点修改成p
  3. 如果p的后继节点是它自己,说明其他线程poll出队构建成哨兵节点,跳过本次循环
  4. 其他情况则向后遍历
     public E poll() {
         //方便退出双重循环
         restartFromHead:
         for (;;) {
             //h记录头节点
             //p真正头节点
             //q为p的后继节点
             for (Node<E> h = head, p = h, q;;) {
                 //获取p节点的数据
                 E item = p.item;
                 //情况1:
                 //如果数据不为空 说明p节点为真正头节点
                 //尝试CAS将数据设置为null,如果数据为item则替换为null,失败则说明其他线程以及出队,继续循环
                 if (item != null && p.casItem(item, null)) {
                     //如果当前头节点不是真正头节点则更新头节点
                     if (p != h) 
                         updateHead(h, ((q = p.next) != null) ? q : p);
                     return item;
                 }
                 //情况2:
                 //p的后继节点为空,说明当前为空队列,尝试CAS将头节点修改为p(p此时可能是哨兵节点)
                 else if ((q = p.next) == null) {
                     updateHead(h, p);
                     return null;
                 }
                 //情况3:
                 //如果p的后继节点指向p自己,说明其他线程poll出队时构建成哨兵节点,跳过本次循环
                 else if (p == q)
                     continue restartFromHead;
                 //情况4:
                 //p定位为后继节点需要遍历
                 else
                     p = q;
             }
         }
     }

在更新头节点方法中,会进行判断

如果当前头节点不是真正头节点,则尝试CAS将头节点设置成p真正头节点

CAS成功后将原来的头节点的next指向它自己,构建成哨兵节点

final void updateHead(Node<E> h, Node<E> p) {
    if (h != p && casHead(h, p))
        h.lazySetNext(h);
}

流程图实现

想要跟着debug的同学,需要把idea中的这两个设置关闭,否则debug会有误

image.png

为了更容易的理解,我们来看一段简单的代码,并附带其实现流程图

	public void testConcurrentLinkedQueue()  {
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

        queue.offer("h1");
        queue.offer("h2");
        queue.offer("h3");

        String p1 = queue.poll();
        String p2 = queue.poll();
        String p3 = queue.poll();
        String p4 = queue.poll();

        queue.offer("h4");
        System.out.println(queue);
    }

【声明:如果图中节点item没写数据,说明存储的数据为空;如果节点next没画指向关系,也说明为空】

执行构造时,会初始化首尾节点指向同一个数据为空的节点

image.png

在第一次入队时,一进入循环就满足第一种情况,此时的p就是真正尾节点,直接CAS设置next为新节点,但由于p与tail相同,就不会更新尾节点tail

因此首尾节点还是哨兵节点,而哨兵节点的next指向新入队的节点

image.png

在第二次入队时,由于此时的p(tail)不是真正尾节点,会来到第三种情况,由于tail没被修改过,p会被改成它的后继节点,继续向后遍历

在第二次循环时,p就是真正尾节点,于是尝试CAS添加新节点,由于此时p和尾节点tail不同,于是会更新tail

image.png

在第三次入队时,情况与第一次入队相同

image.png

此时队列中存在哨兵节点和h1、h2、h3四个节点

在第一次出队时,由于head指向的哨兵节点数据域为空,会来到第四种情况,即将p改为它的后继节点,继续向后遍历

在第二次循环时,p为h1节点,由于数据不为空,CAS将数据设置为空

p.casItem(item, null) 将原h1节点数据设置为空

image.png

此时head并不是真正头节点,于是会更新head

image.png

然后将原来的head指向它自己,构建成哨兵节点,方便中间两个不再使用的节点GC

image.png

在第二次出队时,满足第一种情况,直接CAS将h2节点数据设置为空,不会更新头节点

image.png

在第三次出队时,也类似与第一次出队,满足第四种情况

在第二次循环时,去CAS将数据设置为空,更新头节点,将原来的头节点设置成哨兵节点

image.png

在第四次出队时会满足第三种情况,但此时p就是首节点,因此不会更新首节点,然后返回Null

此时我们可以发现尾节点tail在哨兵节点上,如果往后遍历是永远无法到达队列的

再进行一次入队操作,发现它满足第二种情况,p的next指向自己,由于未被修改过,p等于头节点,又重新回到队列上

再进入一轮循环,会CAS添加h4再更新尾节点tail

image.png

至此,该简单示例覆盖大部分入队、出队的流程,再来聊聊哨兵节点

在此过程中,哨兵节点可以避免队列中只有一个节点而发生竞争

总结

ConcurrentLinkedQueue基于单向链表实现,使用volatile保证可见性,使得在读场景下不需要使用其他同步机制;使用乐观锁CAS+失败重试保证写场景下操作的原子性

ConcurrentLinkedQueue使用延迟更新首尾节点的思想,大大减少CAS次数,提升并发性能;使用哨兵节点,降低代码复杂度,避免一个节点时的竞争

在入队操作时,会在循环中找到真正的尾节点,使用CAS添加新节点,再判断是否CAS更新尾节点tail

在入队操作的循环期间一般情况下是向后遍历节点,由于出队操作会构建哨兵节点,当判断为哨兵节点(next指向自己)时,根据情况定位到尾节点或头节点(“跳出”)

在出队操作时,也是在循环中找到真正的头节点,使用CAS将真正头节点的数据设置为空,再判断是否CAS更新头节点,然后让旧的头节点next指向它自己构建成哨兵节点,方便GC

在出队操作的循环期间一般情况下也是向后遍历节点,由于出队会构建哨兵节点,当检测到当前是哨兵节点时,也要跳过本次循环

ConcurrentLinkedQueue基于哨兵节点、延迟CAS更新首尾节点、volatile保证可见性等特点,拥有非常高的性能,相对于CopyOnWriteArrayList来说适用于数据量大、并发高、频繁读写、操作队头、队尾的场景

作者:菜菜的后端私房菜
链接:https://juejin.cn/post/7278286913944272956
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

【Java多线程】JUC之并发容器—深入剖析并发队列ConcurrentLinkedQueue(九) **ConcurrentLinkedQueue**:是一个适用于**高并发场景**,基于`单向链表`实现的`无界非阻塞线程安全队列`,使用`CAS自旋+volatile`来包保证线程安全。按照`FIFO`的方式对存储元素进行排序,该队列`不允许写入null元素`。 - 由于是完全基于`无锁算法`实现的,多线程同时进行修改队列的操作(比如同时入队),很可能出现`CAS修改失败`的情况,那么失败的线程`会进入下一次自旋,再尝试入队操作,直到成功`。**所以,在并发量适中的情况下,ConcurrentLinked 阅读详情

相关推荐

【java】java 并发编程 ConcurrentLinkedQueue

ConcurrentLinkedQueue的数据结构与LinkedBlockingQueue的数据结构相同,都是使用的链表结构。ConcurrentLinkedQueue的数据结构如下:说明: ConcurrentLinkedQueue采用的链表结构,并且包含有一个头节点和一个尾结点。ConcurrentLinkedQueue是线程安全的队列,它适用于“高并发”的场景。它是一个基于链接节点的无界线程安全队列,按照 FIFO(先进先出)原则对元素进行排序。

九师兄 431

一篇文章带你深度剖析高效读写的队列:ConcurrentLinkedQueue类

队列Queue也是常用的数据结构之一。在JDK中提供了一个ConcurrentLinkedQueue类用来实现高并发的队列。从名字可以看到,这个队列使用链表作为其数据结构。有关ConcurrentLinkedQueue类的性能测试大家可以自行尝试,这里限于篇幅就不再给出性能测试的代码了。 大家只要知道ConcurrentLinkedQueue类应该算是在高并发环境中性能最好的队列就可以了。它之所以能有很好的性能,是因为其内部复杂的实现 作为一个链表,自然需要定义有关链表内的节点,在ConcurrentLin

南淮北安的博客 1091

【Java并发编程】6.常见并发容器

跳表 简而言之跳表就是多层链表的结合体,跳表分为许多层(level),每一层都可以看作是数据的索引,这些索引的意义就是加快跳表查找数据速度。每一层的数据都是有序的,上一层数据是下一层数据的子集,并且第一层(level 1)包含了全部的数据;层次越高,跳跃性越大,包含的数据越少。并且随便插入一个数据该数据是否会是跳表索引完全随机的跟玩骰子一样,redis中的zset底层就是跳表数据结构。并且跳表的速...

sowhat 3149

并发队列

  先进先出(FIFO):先插入的队列的元素也最先出队列,类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。   后进先出(LIFO):后插入队列的元素最先出队列,这种队列优先处理最近发生的事件。 在并发队列上JDK提供了两套实现,一个是以ConcurrentLinkedQueue为代表的高性能队列,一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继...

学而无止境 1674

从梯度泄露到数据复原:DLG与iDLG算法实战解析

本文深入解析了DLG与iDLG算法在梯度泄露与数据复原中的实战应用,揭示了联邦学习中的隐私风险。通过详细代码示例和实验数据,展示了如何从梯度中复原原始训练数据,并探讨了梯度压缩、差分隐私等防御措施。文章特别强调了iDLG算法在标签破解中的高效性,为AI安全领域提供了重要参考。

weixin_30552811的博客 193

pytorch多层感知机实现假钞识别(完整项目构建)

目录1 项目构建2 超参数设置 config.py3 数据集预处理 preprocess.py4 数据集类构建 dataset_banknote.py5 模型构建 model.py6 训练trainer.py6.1 查看损失曲线7 在测试集上运行 inference.py 1 项目构建 构建项目文件夹Banknote,以及子文件夹与py文件。 名称 作用 data目录 存放原始数据与预处理后切分为训练集、验证机、测试集的数据 log目录 存放训练过程中保存的指标,如损失、精确度等

Demon_LMMan的博客 2027

12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue

在阅读本文前,需要理解CAS、volatile等知识基于单向链表实现,使用volatile保证可见性,使得在读场景下不需要使用其他同步机制;使用乐观锁CAS+失败重试保证写场景下操作的原子性使用延迟更新首尾节点的思想,大大减少CAS次数,提升并发性能;使用哨兵节点,降低代码复杂度,避免一个节点时的竞争在入队操作时,会在循环中找到真正的尾节点,使用CAS添加新节点,再判断是否CAS更新尾节点tail。

欢迎来到我的博客 181

Scrum中敏捷项目经理(Scrum Master)扮演什么角色?

Scrum Master是Scrum团队中的“服务员”,负责确保所有人都能理解Scrum的理论、实践和规则,以及帮助团队最大化Scrum的利益。Scrum Master服务于Product Owner,帮助Product Owner理解如何使团队的工作最有效地满足产品目标。Scrum Master服务于Development Team,移除开发团队工作上的障碍,保证团队按照Scrum的方式运作。Scrum Master不是团队领导。Scrum团队是自组织的,意味着团队具有做出决策的能力。

huaqianzkh的专栏 2519

Java 并发容器(含 ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue、BlockingQueue等)

JDK提供的这些容器大部分在包中。线程安全的 HashMap线程安全的 List,在读多写少的场合性能非常好,远远好于 Vector.高效的并发队列,使用链表实现。可以看做一个线程安全的 LinkedList,这是一个非阻塞队列。这是一个接口,JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列,非常适合用于作为数据共享的通道。跳表的实现。这是一个 Map,使用跳表的数据结构进行快速查找。在很多应用场景中,读操作可能会远远大于写操作。

rc1596919047的博客 1505

数字后端实战指南 | Innovus Function ECO全流程解析(从LAB到Tapeout)

本文深入解析了在Cadence Innovus工具中进行Function ECO的全流程实战指南。从LAB环境搭建到Tapeout前的签核验证,详细拆解了Pre-mask与Post-mask ECO的核心步骤、关键命令(如ecoDesign)以及常见避坑方案。重点阐述了如何应对时序、DRC等挑战,并强调了备用单元管理与严格验证的重要性,是数字后端工程师提升综合能力的必备参考。

weixin_28452161的博客 644

从Demo到产品:基于ADAU1452的ANC方案,硬件选型、性能优化与避坑指南

本文详细解析了基于ADAU1452的主动降噪(ANC)方案从Demo到产品的实现路径,涵盖硬件选型、性能优化与实战避坑指南。重点探讨了ADAU1452与ADAU1466的性能差异、编解码器选型策略,以及MFXLMS算法优化技巧,为工程师提供从理论验证到量产落地的系统级解决方案。

weixin_30542079的博客 453

并发容器之ConcurrentLinkedQueue

ConcurrentLinkedQueue是基于链接节点的无界线程安全队列。此队列按照FIFO(先进先出)原则对元素进行排序。队列的头部是队列中存在时间最长的元素,而队列的尾部则是最近添加的元素。新的元素总是被插入到队列的尾部,而队列的获取操作(例如poll或peek)则是从队列头部开始。

小斜同学的博客 1254

结构力学本构模型:复合材料模型:复合材料热力学行为技术教程_2024-08-07_06-54-53.Tex

热塑性复合材料是一种由热塑性树脂基体和增强纤维组成的复合材料。与热固性复合材料不同,热塑性复合材料在加热时可以软化,冷却时硬化,这一过程可以重复进行,因此它们具有可回收和可再加工的特性。热塑性树脂,如聚酰胺(尼龙)、聚碳酸酯、聚醚醚酮(PEEK)等,与碳纤维、玻璃纤维等增强材料结合,可以制备出具有高强度、高刚度和良好耐热性的复合材料。热粘弹性理论是研究材料在温度变化和时间依赖性载荷作用下的变形和应力响应。复合材料,由于其独特的微观结构,展现出复杂的热粘弹性行为。

810

并发容器之ConcurrentLinkedQueue详解

简介 在并发编程中我们有时候需要使用线程安全的队列。如果我们要实现一个线程安全的队列有两种实现方式一种是使用阻塞算法,另一种是使用非阻塞算法。使用阻塞算法的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和出队用不同的锁)等方式来实现,而非阻塞的实现方式则可以使用循环CAS的方式来实现,下面我们一起来研究下Doug Lea是如何使用非阻塞的方式来实现线程安全队列ConcurrentLinkedQueue的。 ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列,它采用先进

GSON的博客 1878

芯片ATE测试PAT(Part Average Testing)学习总结-20250916

文章摘要:零件平均测试(PAT)是半导体制造中基于统计学的质量控制方法,分为静态和动态两种类型。静态PAT通过预先设定的固定限值(每6-8批次更新)筛选异常芯片,计算采用稳健平均值和四分位间距。动态PAT则根据实时数据调整限值,能更精确识别异常而不误判合格芯片。两种方法均采用"均值±6倍标准差"的计算公式,但动态PAT具有更好的适应性和准确性。该方法通过统计分析提高了芯片产品的质量和可靠性。

歌颂苦难的行为是无耻的; 1194

Java并发队列ConcurrentLinkedQueue详解

在当今的软件开发领域,高并发已经成为一个不可忽视的关键问题。尤其是在处理大量数据和高频操作的场景下,如何保证系统的稳定性和效率,成为了开发者们关注的焦点。Java作为一门广泛应用于企业级应用开发的语言,提供了丰富的并发工具和类库。其中,ConcurrentLinkedQueue作为Java并发集合框架中的一个重要组成部分,以其高效的并发性能和简洁的API设计,在处理高并发场景下队列操作时显得尤为重要。

我是Java程序员廖志伟,感谢朋友们的支持! 1623

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

并发容器学习—ConcurrentLinkedQueue和ConcurrentLinkedDuque

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34321977的博客 788

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java并发(十一)一文搞懂Java并发各种容器

同步容器将所有对容器状态的访问都串行化,以保证线程安全性,这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器,使用并发容器来替代同步容器,可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度,降低阻塞,从而提高并发性;Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。

m0_58466443的博客 1260

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

从并发容器ConcurrentLinkedQueue看解决并发问题的设计思路

本次问题模拟火车票售票情景,假设有一台服务器终端内部存储10000张火车票,终端下属十台客户端,十台客户端同时对外进行售票 1.代码模式-错误示例, 此模式下不能解决并发问题,因为每次判断与售票都要对容器进行操作 /** * 不使用任何辅助的时候高并发会出现线程不安全的漏洞 * 线程容器List 不是同步的 * 同时 判断跟递减之间没有原子性 * Created by 阿杜 on

du771278794的博客 1236

一文彻底搞懂并发容器

并发容器是一种用于多线程环境的数据结构,它们能够有效地处理并发访问和修改的问题。在多线程应用程序中,多个线程可能会同时访问和修改共享的数据结构,这可能会导致数据不一致、竞态条件和其他并发问题。并发容器通过实现特定的算法和机制来确保线程安全性,从而有效地管理共享数据结构的并发访问。

永远在路上 1275

ConcurrentLinkedQueue 与 CopyOnWriteArrayList:无锁并发容器原理

传统容器如ArrayListLinkedList在并发访问时需要加锁,而Vector虽然线程安全,但由于锁粒度大、阻塞严重,在高并发环境下性能低下。于是,JUC()提供了一系列无锁(Lock-Free)容器依赖CAS(Compare-And-Swap)原子操作来保证线程安全。→ 无锁链表队列→ 写时复制列表这两者分别代表了:一类是基于CAS 的无锁并发结构一类是基于读写分离的快照思想。和是无锁并发编程前者体现了CAS + 链表 + 自旋的高并发入队出队;后者体现了。

dividividiv的博客 1101

Java并发容器-ConcurrentLinkedQueue

Java并发容器-ConcurrentLinkedQueue概述简介示例代码 概述 马老师多线程视频学习总结(好记性不如烂笔头)。Java并发容器-ConcurrentLinkedQueue学习。 简介 实现一个线程安全的队列有两种实现方式:一种是使用阻塞算法,阻塞队列就是通过使用加锁的阻塞算法实现的;另一种非阻塞的实现方式则可以使用循环CAS(比较并交换)的方式来实现。 ConcurrentL...

wz122330的博客 379

Java 入门指南:Java 并发编程 —— 并发容器 ConcurrentLinkedQueue

ConcurrentLinkedQueue 是Java中的一个并发队列实现,是一个基于链接节点(链表)的无界的线程安全非阻塞队列,适用于多线程环境下的并发访问,即多个线程访问同一个 collection 的场景。 ConcurrentLinkedQueue 采用了无锁(lock-free)的算法实现,并且基于链表数据结构。它支持高效的并发插入和删除操作,以及无界的队列长度。

热带鱼的技术博客 1624
上一篇: 10分钟从源码级别搞懂AQS(AbstractQueuedSynchronizer)
下一篇: MySQL的优化利器⭐️索引条件下推,千万数据下性能提升273%
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值