java源码阅读 - LinkedList(附动图说明)

已于 2023-02-15 14:33:26 修改
阅读量270 收藏
点赞数
分类专栏： 集合 源码 文章标签： java
于 2022-11-14 22:34:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36234720/article/details/127857049
版权

文章目录

目录

在这里插入图片描述

一、介绍

前面我们深度分析了ArrayList的源码和使用方法，它的底层是通过数组来保存每一个元素的（从ArrayList名字也显而易见），但是由于ArrayList读取快、增删慢的特点，决定了它适合于频繁读取的场景。那么如果是增删操作频繁的场景该怎么办？

今天的主角上场，铛铛铛铛~，它就是LinkedList。

顾名思义，这是一个底层数据结构采用链表的集合，而链表的特点就是顺序访问、读取慢、增删快。

看一下他的UML类图：

在这里插入图片描述

从UML类图中可以看到：

  • 实现了Serializable接口，说明LinkedList支持序列化
  • 实现了List接口，说明满足List集合规范，表示LinkedList是一个集合
  • 实现了Deque接口，说明满足双端队列规范，表示LinkedList是一个双端队列或栈
  • 实现了Cloneable接口，说明LinkedList可克隆。
  • 继承自AbstractSequentialList类，提供了顺序访问的基础支持，而AbstractList提供的是随机访问的支持。

虽然LinkedList既可以作为双端队列使用，也可以作为双向链表使用，但本文主要介绍它作为双向链表时的源码部分，因为看过双端队列的源码后会发现，他和双向链表只是从宏观来看有不同的应用，但是他们的微观层面的代码逻辑其实是相同的。

如果对双端队列部分感兴趣，可以自行前往源码阅读。

二、成员变量

transient int size = 0;

/**
  * 指向头节点
  * Invariant: (first == null && last == null) || (first.prev == null && first.item != null)
  */
transient Node<E> first;

/**
  * 指向尾节点
  * Invariant: (first == null && last == null) || (last.next == null && last.item != null)
  */
transient Node<E> last;

// 内部类
private static class Node<E> {
    // 实际保存的元素
    E item;
    // 后置节点
    Node<E> next;
    // 前置节点
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

三、数据结构

LinkedList内部采用双向链表的数据结构来保存元素，从成员变量中也是可以看出来的。

链表中每一个节点用Node对象表示，在Node对象中，item表示当前节点实际保存的数据，next表示当前节点在链表中的下一个节点，prev表示当前节点在链表中的前一个节点。

链表的第一个元素用first属性表示，最后一个元素用last属性表示。如果为空链表，则first属性和last属性都指向null。

因此，LinkedList内部数据结构可以用下图表示。

在这里插入图片描述

思考：为什么使用双向链表而不是单向链表？

单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入、删除操作时)，只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。

双向链表在节点中添加了一个prev属性来表示当前节点的前驱结点，虽然在按值查找和按位查找在时间复杂度上和单向链表相同，但是在插入和删除方面双向链表有着巨大的优势。

拿删除来举例，删除单向链表中的节点时，因节点中只有next属性，为了保证删除节点后不断链，需要遍历链表以得到待删除节点的前驱结点，因此时间复杂度为O(n)；而在双向链表的节点中还有prev属性，因此在删除节点时就可以直接得到前驱结点，从而保证不断链，因此时间复杂度为O(1)。

四、基本操作

作为一个双向链表，最基本的功能就是新增、删除、查找。下面我们来看一下LinkedList是如何实现的。

1、新增

  • 在链表头部新增

    private void linkFirst(E e) {
    // 声明一个临时变量f指向first节点
    // 此时链表为first(f) <-> ... <-> last
    final Node<E> f = first;
    // 根据参数，实例化一个节点newNode，并使该节点的next指向first节点
    // 此时链表为newNode <-> first(f) <-> ... <-> last
    final Node<E> newNode = new Node<>(null, e, f);
    // first指向新节点，此时临时变量f依然指向原first节点，
    // 此时链表为first(newNode) <-> f <-> ... <-> last
    first = newNode;
    
    if (f == null)
        // 如果f节点为null，则说明当前链表只有first(newNode)这一个节点，需要将last指向该节点
        last = newNode;
    else
        // 否则，f节点的prev应指向first(newNode)
        f.prev = newNode;
    
    // 最后链表大小加一，结构修改次数加一
    size++;
    modCount++;
}

在这里插入图片描述

  • 在链表尾部新增

    void linkLast(E e) {
    // 声明一个临时变量l指向last节点
    // 此时链表为first <-> ... <-> last(l)
    final Node<E> l = last;
    // 根据参数，实例化一个节点newNode，并使该节点的prev指向last节点
    // 此时链表为first <-> ... <-> last(l) <-> newNode
    final Node<E> newNode = new Node<>(l, e, null);
    // last指向新节点，此时临时变量l依然指向原last节点，
    // 此时链表为first <-> ... <-> l <-> newNode(last)
    last = newNode;
    if (l == null)
        // 如果l节点为null，则说明当前链表只有newNode(last)这一个节点，需要将first指向该节点
        first = newNode;
    else
        // 否则，l节点的next应指向newNode(last)
        l.next = newNode;
    
    // 最后链表大小加一，结构修改次数加一
    size++;
    modCount++;
}

    在这里插入图片描述

  • 在指定结点之前新增

    /**
 * 在指定的节点succ前面插入数据e
 * 注意：指定的节点succ不能为空，否则会抛出空指针异常
 * @param e 要插入的数据
 * @param succ 指定的节点
 **/
void linkBefore(E e, Node<E> succ) {
    // 根据succ.prev获得原链表中succ的前置节点
    // 此时链表结构不变，first <-> ... <-> pred <-> succ <-> ... -> last
    final Node<E> pred = succ.prev;
    // 根据元素e，实例化一个新的节点newNode，新节点的前置节点指向pred，后置节点指向succ，
    // 此时链表结构为，first <-> ... <-> pred <-> (newNode) <-> succ <-> ... <-> last
    // prev节点的next依然指向succ节点，succ的prev依然指向prev节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 将succ的prev从prev节点指向newNode节点
  // 此时链表结构为，first <-> ... <-> pred <-> (newNode <-> succ <-> ... <-> last
    // prev节点的next依然指向succ节点，而succ的prev则指向newNode节点
    succ.prev = newNode;
    
    if (pred == null)
        // 如果pred节点为null，说明在原链表中succ节点即为首节点first，即succ(first) <-> ... <-> last
        // 这种情况下在succ节点前面添加newNode节点，则newNode节点应为现链表中的首节点first
        // 此时链表结构为，newNode(first) <-> succ <-> ... <-> last
        first = newNode;
    else
        // 否则，说明在原链表中succ节点不是首节点first，即first <-> succ <-> ... <-> last
        // 则需要将pred节点的next从succ节点指向newNode节点
        // 此时链表结构为，first <-> ... <-> pred <-> newNode <-> succ <-> ... <-> last
        pred.next = newNode;
    
    // 最后链表大小加一，结构修改次数加一
    size++;
    modCount++;
}

    在这里插入图片描述

2、删除

  • 删除头部结点

    /**
 * @param f 头部节点，
 * 在调用此方法前，需要保证f节点为头结点first，且不为空
 **/
private E unlinkFirst(Node<E> f) {
    // 获取f节点中的元素element，待方法执行结束后返回
    final E element = f.item;
    // 将f节点的next节点赋值给临时变量next
    // 此时链表结构为f(first) <-> next <-> ... <-> last
    final Node<E> next = f.next;
    
    // 将f节点内的item和next属性置为null，因为f节点是头结点，因此prev属性本就为null
    // 置为null的目的是释放内存
    f.item = null;
    f.next = null;
    // 将first指向f节点的next节点，
    // 此时链表结构为f <-> next(first) <-> ... <-> last
    first = next;
    if (next == null)
        // 如果next节点为null，说明原链表只有f(first)一个节点
        last = null;
    else
        // 如果next节点不为null，说明原链表有多个节点
        // 此时链表结构为f -> next(first) <-> ... <-> last
        // 因为first节点表示首节点，因此链表结构可表示为 next(first) <-> ... <-> last
        next.prev = null;
    
    // 删除成功，size减一，修改次数加一
    size--;
    modCount++;
    // 将已删除节点f的元素返回
    return element;
}

    在这里插入图片描述

  • 删除尾部结点

    /**
 * @param l 尾部节点，
 * 在调用此方法前，需要保证l节点为尾结点last，且不为空
 **/
private E unlinkLast(Node<E> l) {
    // 获取l节点中的元素element，待方法执行结束后返回
    final E element = l.item;
    // 将l节点的prev节点赋值给临时变量prev
    // 此时链表结构为first <-> ... prev <-> last(l)
    final Node<E> prev = l.prev;
    
    // 将l节点内的item和prev属性置为null，因为l节点是尾结点，因此next属性本就为null
    // 置为null的目的是释放内存
    l.item = null;
    l.prev = null;
    // 将last指向l节点的prev节点，
    // 此时链表结构为first <-> ... <-> prev(last) <-> l
    last = prev;
    if (prev == null)
        // 如果prev节点为null，说明原链表只有l(last)一个节点
        first = null;
    else
        // 如果prev节点不为null，说明原链表有多个节点
        // 此时链表结构为first <-> ... <-> prev(last) <- l
        // 因为first节点表示首节点，因此链表结构可表示为 first <-> ... <-> prev(last)
        prev.next = null;
    
    // 删除成功，size减一，修改次数加一
    size--;
    modCount++;
    // 将已删除节点f的元素返回
    return element;
}

    在这里插入图片描述

  • 删除指定结点

    /**
 * 调用此方法前需要保证x节点不为空
 */
E unlink(Node<E> x) {
    // 获取x节点中的元素element，待方法执行结束后返回
    final E element = x.item;
    // 获取x节点的前置节点prev和后置节点next
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    // 链表结构为 first <-> ... <-> prev <-> x <-> next <-> ... <-> last

    // 处理x节点左边的节点
    if (prev == null) {
        // 如果prev节点为null，说明x节点为头结点，
        // 在删除x节点后，next节点就变成了first节点
        // 此时链表结构为 next(first) <-> ... <-> last
        first = next;
    } else {
        // 如果prev节点不为null，说明x节点不是头结点，
        // 在删除x节点后，prev节点的next属性就指向next节点
        prev.next = next;
        // 将x的prev属性置为空，内存回收
        x.prev = null;
        // 此时结构为： 
        // prev节点后置节点为next，x的后置节点为next，next的前置节点为x
    }

    // 处理x节点右边的节点
    if (next == null) {
        // 如果next节点为null，说明x节点为尾结点，
        // 在删除x节点后，prev节点就变成了last节点
        // 此时链表结构为 first <-> ... <-> prev(last)
        last = prev;
    } else {
        // 如果next节点不为null，说明x节点不是尾结点，
        // 在删除x节点后，next节点的prev属性就指向prev节点
        next.prev = prev;
        // 将x的next属性置为空，内存回收
        x.next = null;
        // 此时结构为： 
        // prev节点后置节点为next，next的前置节点为prev
        // 即 first <-> ... <-> prev <-> next <-> ... <-> last
    }

    // 将x的item属性置为空，内存回收
    x.item = null;
    // 删除成功，size减一，修改次数加一
    size--;
    modCount++;
    // 方法最后返回x节点中的元素值
    return element;
}

    在这里插入图片描述

3、查找

  • 查找头部

    LinkedList的成员变量中有一个first属性，该属性始终表示内部双向链表的首节点，获取链表的第一个元素，只要将首节点中的元素取出即可

    public E getFirst() {
    // 将first赋值给final修饰的临时变量f
    final Node<E> f = first;
    // 如果f为空，则抛出异常
    if (f == null)
        throw new NoSuchElementException();
    // 如果f不为空，则将f节点中的元素返回
    return f.item;
}

    思考：为什么不能直接对first进行非空判断，而是要再声明一个final修饰的临时变量f，转而对这个临时变量进行判断呢？

    上面问题所表达的代码逻辑如下所示，差别在于省去了中间变量的操作；

    public E getFirst() {
    if (first == null)
        throw new NoSuchElementException();
    return first.item;
}

    这样的逻辑乍一看没有问题，但其实忽略了多线程环境下的考虑、以及final关键字的作用：

    试想一下：有一个多线程之间共享的LinkedList变量

    • 线程A在调用getFirst()方法中，条件语句first == null为false，则应该执行下一行代码：return first.item，但此时线程A失去CPU调度
    • 线程B获得CPU调度，但是线程B直接对这个变量调用clear()方法将链表清空了
    • 此时线程A重新获得CPU调度并继续执行代码：return first.item，但是该链表已经被线程B清空了，因此会抛出空指针异常

    改进：

    • 将first变量使用final关键字修饰，这样就可以避免其他线程对其进行修改了，但是这样的话只要涉及到修改first变量的所有操作都将报错

    优化：

    • 声明一个final修饰的中间变量指向first节点，这样既避免了其他线程的干扰，也可以避免修改first变量的所有操作的报错问题

  • 查找尾部

    LinkedList的成员变量中有一个last属性，该属性始终表示内部双向链表的尾节点，获取链表的最后一个元素，只要将尾节点中的元素取出即可

    public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

  • 获取指定元素的索引

    该操作是为了获取指定元素在当前链表中首次出现时的位置，即获取指定元素在链表中的最小索引。

    因为LinkedList的底层结构为链表，它并不像ArrayList一样能直接提供某个元素在数组中的下标，因此需要从首节点(first)逐一遍历整个链表，直到某个节点中的元素与当前指定元素相等(equals()方法返回true)为止，此时的时间复杂度为O(n)。

    public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        // 如果指定元素为null，则从首节点至尾节点逐一遍历，直到遇到一个元素为null为止，返回index
        // 在遍历的过程中，每遍历一个节点，index加一
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        // 与上面的逻辑一致
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    // 如果当前链表中不存在指定元素，则返回-1表示不存在
    return -1;
}

    下面我们以查找某一个链表中存在的元素为例，用动图来演示一下此方法的逻辑

    在这里插入图片描述

  • 移除指定元素

    在了解indexOf(Object o)方法和unlink(Node<E> x)方法后，相信对remove(Object o)方法的源码也了如指掌了

    该方法使用和indexOf(Object o)方法一样的遍历方法，从首节点至尾节点逐一遍历，当遍历到某个节点时发现该节点的元素和参数相等，就表示删除当前节点即可，删除节点直接调用unlink(Node<E> x)方法即可。

    public boolean remove(Object o) {
    if (o == null) {
        //  对链表中的节点逐一遍历
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                // 遍历过程中当前节点的元素值与参数一致，调用unlink(Node<E> x)方法删除当前节点即可
                unlink(x);
                // 删除成功后返回true
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    // 如果整个链表中都不存在要删除的元素则返回false
    return false;
}

  • 根据索引获取节点

    通过node(int index) 方法获取指定索引的节点，该方法采用一次二分法来提升查找效率，通过size >> 1将当前链表从中间一分为二，如果参数index位于链表的前半段，则只需要从first到中间位置正序遍历，如果参数index位于链表的后半段，则只需要从last到中间位置倒序遍历。

    Node<E> node(int index) 
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

    但是此逻辑仍有不完美的地方，参数index越趋向于链表中间位置，遍历所需要花费的时间自然也越长，当链表足够长的时候，所需要的时间复杂度依然为O(n)。

    或许设计者是这样想的，链表本身的有点是根据节点来操作，它最怕的就是使用索引操作，能提供给我们一个通过索引来操作的方法就不错了，如果非要用索引操作，请移步基于数组实现的ArrayList。

五、特点

  • 以节点对链表进行操作时，时间复杂度为O(1)，因为每个节点中都包含了前置节点和后置节点的引用，可以直接获取到前后节点
  • 以索引对链表进行操纵时，时间复杂度为O(n)，因为在链表中并没有维护当前节点下标的属性，只能通过遍历来获取指定的节点，然后再对链表进行操作。

六、关注我

本文已同步更新至本人博客网站，是兄弟就来砍我
http://www.zhangks.top:8090/2022/11/14/java源码阅读-linkedlist附动图说明/

理想万岁万万岁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
集合体系架构图
weixin_66119119的博客
04-11 99
集合
一文彻底带你搞清楚LinkedList，通俗易懂
庆哥Java的CSDN技术博客
05-31 973
说到LinkedList那就必然会想到ArrayList，很多人也会将两者进行比较，的确，我们知道在数据结构中，数组和链表称得上是数据结构中的数据结构，也就是说很多高级的数据结构都是在数组或者链表以及两者的基础之上建立而成！对于ArrayLsit而言，它的底层使用的是数组这一数据结构，相对应的，LinkedList则是使用链表作为底层数据结构，而且还是一个双向链表！也就是对于ArrayList而言，它的底层是这样的数组：而对于LinkedList而言，底层则是这样的一个双向链表：那基于链表的一些特性，我们就
LinkedList底层解析
Pedri_的博客
04-26 459
这个方法大致逻辑是：先将尾节点用一个对象常量l保存，随后new一个节点对象newNode，将我们传入的新增元素放入这个对象的item,这个对象的上一个节点为l，下一个节点为空。如果不为空，将l的下个节点指向新节点。与ArrayList不同，LinkedList在底层是通过链表来实现的，每个元素（节点）都包含了一个指向前驱和后继节点的引用。LinkedList可以动态地添加或删除元素，因为它不需要像数组一样移动元素，只需要修改节点的前驱或后继节点的引用即可。只有一个无参构造器和一个传入集合的构造器。
【JAVA集合篇】LinkedList详解
初念初恋的博客
06-17 738
LinkedList和ArrayList数据结构是完全不一样的，ArrayList 底层是数组的结构，而 LinkedList 的底层则是链表的结构， 它可以进行高效的插入和移除的操作，它基于的是一个双向链表的结构。
Java数据结构之图解单链表 + 单链表实例
李思成的博客
06-03 822
链表（Linked List）介绍： 1，链表是以节点的方式来存储是链式存储 2，每个节包含 data域：存储信息next域：指向下一个节点。 3，链表的各个节点不一定是连续存储的。 4，链表分带头结点的链表和没有头节点的链表，根据实际情况来确定 链表在内存中的存储形式： 由此得出：链表的各个节点不一定是连续存储的。 单链表的逻辑结构示意图： 每一个节点Node中都包含一个data域和一个指针域。 链表的操作图解： 创建链表： 1、头插法：把后建立的结点插在头部。用...
java集合 collection-list-LinkedList详解
08-31
下面小编就为大家带来一篇java集合 collection-list-LinkedList详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java集合-LinkedList的使用
06-14
基于双向链表实现的列表，支持在任意位置的插入和删除操作。
javalist源码-LinkedList-in-Java:链表的Java源代码实现
05-19
java list原始代码Java中的LinkedList
Java源码解析LinkedList
08-26
今天小编就为大家分享一篇关于Java源码解析LinkedList，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
kata-linkedlist2-java
05-21
kata-链表2 MM和我练习了链表kata。 注意：名称已被另一次执行的kata占用。 启示 如果您想方便的话可以
用Java实现抖音等各种小视频批量转换为gif动态图
fo_xi的博客
05-08 3690
本文主要介绍了Java用20行代码实现抖音小视频批量转换为gif动态图，分享给大家，具体如下： 效果图 本功能实现需要用到第三方jar包 jave，JAVE 是java调用FFmpeg的封装工具。 1、Java单类实现代码，复制到Spring boot项目中，用idea编辑器 主方法运行。 package com.naughty.userlogin02; import ws.schild.jave.Encoder; import ws.schild.jave.EncoderException; import
LinkedList数据结构图解
热门推荐
u014492665的博客
09-01 1万+
LinkedList集合 具体细节请结合源码自己分析哦： 数据结构图解 add方法详解 特性 数据结构 add方法 特性 1.采用链表结构 适合插入和删除操作 只用改变一下前后节点引用 2.LinkedList 继承自 AbstractSequentialList 接口，同时了还实现了 Deque, Queue 接口，可以用来模拟堆栈，队列，双端队列结构...
JAVA数据结构与算法基础——链表(LinkedList)【云图智联】
06-18 227
在本节中，我们将看到一种新的数据存储结构，它可以解决上面的一些问题。这种数据存储结构就是链表。链表可能是继数组之后第二种使用最广泛的通用存储结构。 在本章中，我们将学习： 单链表 双端链表 有序链表 双向列表 有迭代器的列表 链表与数组一样，都作为数据的基本存储结构，但是在存储原理上二者是不同的。在数组中，数据是存储在一段连续的内存空间中，我们可以通过下标来访问数组中的元素；而在链表中，元素是存储在不同...
Java数据结构-链表(LinkedList)(四)
weixin_45987961的博客
10-28 338
方式三、 什么是链表 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）； 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活； 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 1. 单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元
图解集合2：LinkedList
weixin_34249367的博客
12-02 463
初识LinkedList 上一篇中讲解了ArrayList，本篇文章讲解一下LinkedList的实现。 LinkedList是基于链表实现的，所以先讲解一下什么是链表。链表原先是C/C++的概念，是一种线性的存储结构，意思是将要存储的数据存在一个存储单元里面，这个存储单元里面除了存放有待存储的数据以外，还存储有其下一个存储单元的地址（下一个存储单元的地址是必要的，有些存储结构还存放有其前一个...
JDK源码分析(二)——LinkedList
weixin_30624825的博客
07-18 246
目录 LinkedList LinkedList继承结构 LinkedList内部类Node LinkedList成员属性 LinkedList构造方法 重要方法 Deque方法的实现 遍历 总结 ...
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 479
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
Redis的数据淘汰策略——Java全栈知识（19）
最新发布
dghehe的博客
05-12 480
数据过期策略是 redis 中设置了 TTL 的数据过期的时候 Redis 的处理策略。数据淘汰策略是 Redis 内存不够的时候，数据的淘汰策略：当 Redis 中的内存不够用时，此时在向 Redis 中添加新的 key, 那么 Redis 就会按照某一种规则将内存中的数据删除掉，这种数据的删除规测被称之为内存的淘汰策略。redis 的内存删除策略有：·noeviction: 不会淘汰任何键值对，而是直接返回错误信息。
ssm115乐购游戏商城系统+vue
hjjshua的博客
05-09 606
如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统毕业生学历信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个毕业生学历证明系统，可以解决许多问题。 毕业生学历证明系统实现的功能包括管理用户的签约单位信息，管理用户的学历信息，管理用户的转接地信息，管理基础数据，其中基础信息管理包括部门管理，职位管理，班级管理，成分管理，学习形式管理，学制管理，专业管理，学历性质管理，
javajava实现线程池(附完整源码)
06-09
import java.util.LinkedList; import java.util 7] 1,024 ReLU-118 [-1, 512, 7, 7] 0 Conv2d-119 [-1, 2048, 7, 7] 1,048,576.List; public class ThreadPool { private final int nThreads; private final ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

理想万岁万万岁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值