看到就是赚到!当 LinkedList 不是列表时,速度快的兔子都追不上!

链表(Linked List)算法的使用场景和使用例子详解 python复制代码。 阅读详情

ArrayList和LinkedList有什么区别?

这种侮辱人的问题,默认就把这两者限定在了同一个场景之中,它甚至连八股文都算不上。

一旦你被问到这种问题,也证明面试基本上泡汤了--面试官已经实在是找不到其他问题与你交流了。

你Over了。

但当我们细看一下LinkedList的class定义,就会发现,它并不像是ArrayList的那样具有纯洁的列表精神。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

//VS

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable


LinkedList除了能够当作普通的列表,它还是一个Deque。双向链表,听着就比较唬人,这就是一个既能当做队列、又能当做栈的存在。

有了这种双重Buff的叠加,LinkedList的应用场景比ArrayList丰富的多。除了能做最简单的LRU缓存,LinkedList在刷题的时候也是充满了正能量。

王者ConcurrentLinkedQueue,一个阻塞的双向队列,它的基本操作方法有:(3[基本]x2[异常与返回值]+4[阻塞加超时])x3[队头队尾]=5x2x3=30,足足有30个方法。

不过我们今天要聊的一个重点,是使用Deque来实现更快的延迟队列。

延迟队列

如果你想要某些数据延迟一段时间再进行处理,或者要再某段时间内按照分组进行一些计算,那延迟队列无疑是非常合适的。

在Java的Concurrent包里,就静悄悄的躺着DelayQueue。只要你的数据实现了Delayed接口,那么就可以放心大胆的把它们往里面塞。

可惜的是,DelayQueue的底层存储,使用的是PriorityQueue。

PriorityQueue是堆实现的,offer和poll数据的时间复杂度是O(logN)。这就意味着,当DelayQueue中的数据比较多的时候,它的性能就会下降。

除了把数据分片,使用多个DelayQueue来完成工作,我们有没有速度更快的方法?比如把PriorityQueue使用LinkedList来替换?

这要看场景。

如果你向DelayQueue中添加数据,是与当前添加的时间相关的,那完全可以使用LinkedList来替换PriorityQueue。

关键代码

要了解DelayQueue的运行原理,我们可以需要先看一下Delayed接口。任何想要存储到DelayQueue中的数据,都需要实现这个接口。

其中,getDelay就是用来判断当前数据是否超时的方法。而compareTo,则是PriorityQueue用来排序的,如果我们是按照当前塞入数据的,则compareTo方法就不是必要的。

public long getDelay(@NotNull TimeUnit unit) {
    return MAX_CACHE_DUAL + this.enqueueTimeNs - System.nanoTime();
}
public int compareTo(@NotNull Delayed o) {
    long d = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
    return (d == 0) ? 0 : (d < 0 ? -1 : 1);
}

按照以上的思路,我们把DelayQueue的代码拷贝一份,仅保留关键代码,如下。

public class LightweightDelayedQueue<E extends Delayed> {
    private final transient ReentrantLock lock = new ReentrantLock();
    private final LinkedList<E> q = new LinkedList<>();
    private final Condition available = lock.newCondition();
    private Thread leader;

    public void put(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            q.offer(e);
            if (q.peek() == e) {
                leader = null;
                available.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (; ; ) {
                E first = q.peek();
                if (first == null)
                    available.await();
                else {
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0L)
                        return q.poll();
                    first = null; // don't retain ref while waiting
                    if (leader != null)
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            available.awaitNanos(delay);
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }

    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.size();
        } finally {
            lock.unlock();
        }
    }

    public int drainTo(Collection<? super E> c, int maxElements) {
        Objects.requireNonNull(c);
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int n = 0;
            for (E first;
                 n < maxElements
                         && (first = q.peek()) != null
                         && first.getDelay(NANOSECONDS) <= 0; ) {
                c.add(first);   // In this order, in case add() throws.
                q.poll();
                ++n;
            }
            return n;
        } finally {
            lock.unlock();
        }
    }
}

主要方法

轻量级的延迟队列,如果一旦采用了LinkedList,那么它的入队、出队方法,就都变成了O(1)的时间复杂度。在延迟队列中的数据增加时,时间复杂度也能维持不变,可以说是速度快的连兔子都追不上了。

一般,在java中,put和take方法,都是代表阻塞性方法。比如,take方法,我们可以将其安全的阻塞在某个线程上,而不用担心太多的资源浪费。

final Thread thread = Thread.currentThread();
while (!this.close && !thread.isInterrupted()) {
    Data data = q.take();
}

这一切都是Condition办到的,它和wait、notify的作用是一样的。

当我们通过put方法添加新的数据到队列中,会通过signal方法,来通知等待的线程获取数据。

相同的,如果take方法发现队列中的数据为空,它将进入等待状态。如果有数据,也并不是马上把这些数据取出来,因为数据还没到期。比如最老的数据还剩下5秒才到期,代码也对这种情况进行了处理,它会尝试awaitNanos对应的时间。

这样,我们就可以使用这种简单的轮询方式来实现延迟队列,而不需要单独的线程去检测队列中的数据。

增加take方法的效率

但是这样还不够。

当数据量比较大的时候,队列的数据可能有多条已经到期。如果我们通过take方法来一条一条获取的话,效率自然不如批量获取高。

drainTo方法,可以一股脑的把到期的数据转移到其他的集合中,但它并不是一个阻塞性的方法。

我们可以先使用take来阻塞线程,然后再批量取出所有数据。

下面代码,会一次性获取100条数据作为一个批量。

final Data takeItem = q.take();
final List<Data> buckets = new ArrayList<>(100);
q.drainTo(buckets, 99);
buckets.add(takeItem);

End

实际上,我们的某个业务,当采用LinkedList来替代PriorityQueue,并进行批量操作后,CPU的使用直接降低了1/3。

Deque是xjjdog最喜欢的一个接口。每当使用offerFirst、offerLast这样精准的API进行操作,都会体验到多巴胺的乐趣。LinkedList作为它的儿子,自然拥有了这些所有的功能。

当我们使用concurrent包里的基本API,对这些淳朴的工具进行封装,它们就会焕发出新的活力。

UE5新手必看:3种UI定位方法实战(含蓝图配置截图) 本文为UE5新手详细解析了三种核心UI定位方法:屏幕空间、场景空间和世界空间。通过实战蓝图配置与控件操作,指导开发者如何根据HUD、角色血条、3D物体标记等不同应用场景,正确选择并配置UI的定位方式,以实现清晰的信息传递与沉浸式体验。 阅读详情

相关推荐

图解链表 —— JAVA中的单链表基本操作

文章目录1. 什么是链表2. 链表的种类3. 创建单链表3.1 创建 Node 类(车厢类)3.2 创建 MySingleList (火车类)4. 单链表的基本操作4.1 增加链表元素4.1.1 在链表头部添加元素4.1.2 在链表任意位置添加元素4.1.3 在链表尾部添加元素4.2 删除链表元素4.2.1 删除第一个节点元素4.2.2 删除任意位置 index 元素4.2.3 删除链表中指定元素的第一个节点4.2.4 删除链表的所有指定元素4.3 查找链表元素4.3.1 判断链表中是否包含元素 data4

AlinaQ05的博客 2503

集合LinkedList的常见使用

LinkedList 集合是Java编程语言中的一种双向链表数据结构,它实现了 List 接口和 Deque 接口。 与 ArrayList 类似,LinkedList 也是一种动态数组,可以根据需要动态地增加或减少元素的大小。 然而,LinkedList 与 ArrayList 在内部实现和性能方面有所不同 LinkedList 使用双向链表来存储元素,每个元素都包含一个指向前一个元素和后一个元素的引用,这种结构使得 LinkedList 在插入和删除元素

liyil66464的博客 1662

Pytest 常见问题及其解决方案

Pytest 是一个强大且灵活的测试框架,但初学者在使用过程中难免会遇到各种问题。希望通过这篇文章,你能更好地应对常见的挑战,写出更高效、更稳定的测试代码。测试不是负担,而是保障。写好测试不仅能提高代码质量,还能让你在面对变更时更加从容自信。

qq_52137592的博客 901

ArrayList与LinkedList使用场景与耗时分析

【代码】ArrayList与LinkedList使用场景与耗时分析。

lcb9354的博客 805

帆软 finereport FCRA 考试 题库+答案,共收录561题,大部分有答案

帆软 finereport FCRA 考试 题库+答案,共收录561题,大部分有答案 入门基础 11.多选题 以下方式中属于FineReport中预览模式的有( ) 分页预览、填报预览、新填报预览、数据分析、移动端预览 16.判断题 FineReport报表工具必须购买激活码后才能使用。 错误,可以免费获取激活码。 29.单选题 FineReport是一款利用( )语言开发的报表工具。java 41.多选题 访问帮助文档的方式有哪些?设计器中社区菜单下-帮助文档;直接访问http://help.finere

qq_37485720的博客 2万+

告别抓包:一个Xposed模块教你监控抖音App的本地数据变化

本文详细介绍了如何利用Xposed框架开发模块,实现抖音App本地数据监控的技术方案。通过Hook关键方法,开发者可以实时获取用户信息、推荐算法参数等核心数据,无需Root设备即可高效调试。文章包含完整的环境配置、代码实现和优化技巧,为移动应用开发与测试提供创新解决方案。

weixin_27015733的博客 387

Java17中LinkedList类介绍、应用场景和示例代码

LinkedList是 Java 集合框架中基于双向链表实现的类,实现了List和Deque接口。在 Java 17 中,其核心实现与旧版本保持一致,但在现代 Java 编程中可以结合新特性(如varStream API)更高效地使用。

a_beiyo的博客 905

shader基于高度的权重混合

效果图: 基于高度的权重混合 , 效果描述: (1)混合:三层混合, 例如 第一层是草,第二层是石头,第三层是沙子,三者混合显示 (2)权重: 三层的权重的和 为1, 三者是此消彼长的关系 (3)高度:高度会限制或者说是 束缚 着 效果 关于混合,再多说几句: (1)基于权重的混合:权重 ,跟顺序没有关系 只跟权重的大小有关系(在一层一层界限不清晰的地方,特别适用!!效果极好!!!!) (2)基于叠加的混合: 叠加 就是 一层一层的往上加。。。。 所以顺序特别重要(在雪地等效果中使用:因为

木马人 1119

深入理解Java LinkedList:使用场景与实际应用

在Java的世界里,集合框架是不可或缺的一部分,它提供了一系列用于存储和操作数据集合的接口和类。其中,`LinkedList`作为List接口的一个实现,经常被拿来与`ArrayList`做对比。尽管在实际业务开发中`LinkedList`的使用频率可能不如`ArrayList`高,但这并不意味着它是一个冷门或无用的集合。本文将深入探讨`LinkedList`的特性、优势以及它在实际开发中的合理使用场景。

常备不懈 1774

别再只会用QTcpSocket了!手把手教你用QSslSocket为你的Qt网络应用加上SSL/TLS加密(附完整代码示例)

本文详细介绍了如何将Qt网络应用从QTcpSocket迁移到QSslSocket,实现SSL/TLS加密传输。通过对比API差异、解析核心机制和提供完整代码示例,帮助开发者快速掌握安全网络编程技巧,有效防范数据窃听和中间人攻击等安全风险。

weixin_30654583的博客 401

(11-3-03)多任务与元强化学习:综合实战:基于元强化学习的迷宫导航系统(3)

本文介绍了策略网络隐空间可视化的实现方法及其在强化学习中的应用。通过设计visualize_latent_space函数,使用t-SNE算法将高维隐空间特征降维至二维进行可视化,直观展示策略网络在不同任务中的特征分布。文章详细阐述了实现流程:状态收集、t-SNE降维和可视化绘图,并提供了完整的Python代码示例。实验结果表明,该方法能有效分析策略网络的学习过程与适应能力,为优化模型提供重要依据。同时,文章还介绍了主程序的完整流程,包括环境初始化、元智能体训练与评估、学习策略比较等环节,最后对实验结果进行可

码农三叔 1047

Java集合Collection之LinkedList

最近在复习集合的相关知识点,以前只知道ArrayList的基本用法与功能,发现系统学习后,List的还有另一个实现类LinkedList,学习后发现LinkedList别有洞天。对于不爱学习的我,赶紧记录下,怕以后忘记了这个一个好东西!!!

weixin_52890053的博客 1009

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

当 LinkedList 不是列表时,速度快的兔子都追不上!

ArrayList和LinkedList有什么区别?这种侮辱人的问题,默认就把这两者限定在了同一个场景之中,它甚至连八股文都算不上。一旦你被问到这种问题,也证明面试基本上泡汤了--面试官已经实在是找不到其他问题与你交流了。你Over了。但当我们细看一下LinkedList的class定义,就会发现,它并不像是ArrayList的那样具有纯洁的列表精神。LinkedList除了能够当作普通的列表,它还是一个Deque。双向链表,听着就比较唬人,这就是一个既能当做队列、又能当做栈的存在。

m0_50180963的博客 560

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

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

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

当 LinkedList 不是列表时,速度快的兔子都追不上

ArrayList和LinkedList有什么区别? 这种侮辱人的问题,默认就把这两者限定在了同一个场景之中,它甚至连八股文都算不上。 一旦你被问到这种问题,也证明面试基本上泡汤了--面试官已经实在是找不到其他问题与你交流了。 你Over了。

Javatutouhouduan的博客 528

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

谢飞机的互联网大厂Java面试奇遇记

在一家知名互联网大厂的面试间,严肃的面试官正对着一位自称“编程界泥石流”的水货程序员谢飞机,展开了一场别开生面的Java技术面试。

qq_48969764的博客 802

互联网大厂Java面试实录:谢飞机的爆笑答题之路

JUC是Java Util Concurrent包,提供并发工具如锁、线程池、原子操作等。了解JUC是Java高并发的基础。推荐《Java并发编程实战》,网站Docker是容器技术,将应用及依赖封装,便于部署和迁移。

slyanaldt的博客 659

LinkedList的适用场景

LinkedList是基于双向链表实现,链表中的每个节点都是一个Node类型的对象,Node对象由item、prev、next三部分组成。所以LinkedList适用于需要频繁的删除插入数据,且不需要或少用去随机访问其中元素的读少写多的情况。但当我们随机访问集合中的某一元素时,只能从头或从未依次遍历去访问某一元素。LinkedList 具有:更快速高效地添加删除元素的能力,但遍历效率低。当对集合中的元素进行操作时只需要操作其 next prev的指向。节点中会记录当前元素的组成方便完成指向关系。

2302_77039865的博客 392

ArrayList和LinkedList区别

1).ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 2).对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。 3).对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。 实现原理:http://zhangshixi.iteye.com...

dpwangyanli的专栏 265

ArrayList 和 LinkedList:特性、差异与应用场景

例如,在一个学生成绩管理系统中,如果经常需要根据学生的编号(索引)查询成绩,使用ArrayList可以快速定位到对应的成绩信息,提高系统的响应速度。以插入操作为例,当在链表中某个节点A之后插入一个新节点B时,只需要修改A节点的后继引用指向B,以及B节点的前驱引用指向A,同时将B节点的后继引用指向A原来的后继节点。例如,假设有一个存储了大量商品价格的ArrayList,我们可以直接使用prices.get(index)来快速获取特定位置的价格信息,无论列表中有多少个元素,这种访问操作的时间几乎是恒定的。

hdy8481140的博客 838

LinkedList的特点及应用场景

例如:LinkedList<String> stack = new LinkedList<>();:使用节点(Node)存储数据,每个节点包含数据本身以及指向前后节点的引用。指定位置插入/删除平均时间复杂度O(n)(需要先遍历到指定位置)LinkedList实现了Deque接口,适合作为栈或队列使用。:按索引访问元素需要从头或尾开始遍历,时间复杂度O(n):除了存储数据外,每个节点还需要存储前后节点的引用。:既可以作为列表使用,也可以作为双端队列使用。:非连续内存空间,节点可以分散在内存各处。

Littlegarbage_的博客 441

LinkedList 在项目中的应用

LinkedList在需要频繁插入和删除的应用中非常高效,适合用作队列、双端队列、栈以及其他需要动态大小和灵活性的场景。选择使用LinkedList要根据具体的需求和性能考虑来决定。

770

Java 集合框架中的 ArrayList 和 LinkedList:实现、性能差异和适用场景

本文深入分析了 Java 中的 ArrayList 和 LinkedList 数据结构,探讨了它们的基本概念、实现原理、性能差异和遍历方式。文章重点讲解了 ArrayList 的扩容规则及其内部实现,以及 Fail-Fast 和 Fail-Safe 迭代器的区别和应用场景。本文旨在帮助读者更好地理解这两种数据结构的内部机制和适用场景。

m0_53368182的博客 1349

Java 常用List集合使用场景分析

看到这里,如果面试官问你ArrayList和LinkedList有什么区别时如果你回答:ArrayList查询快,写数据慢;LinkedList查询慢,写数据快。面试官只能算你勉强合格。如果你回答:ArrayList查询快是因为底层是由数组实现,通过下标定位数据快。写数据慢是因为复制数组耗时。LinkedList底层是双向链表,查询数据依次遍历慢。写数据只需修改指针引用。

asdfgha14的博客 367
上一篇: SpringBoot+WebSocket实现即时通讯(J2EE方式)
下一篇: Eureka源码-源码环境搭建
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值