LinkedHashMap源码及LRU实现原理

基本认识

 

LinkedHashMap位于java.util包,于JDK1.4引入,属于Java Collections Framework的成员。查看其UML关系如下图所示:LinkedHashMap源码及LRU实现原理_第1张图片
HashMap在很多场景下都满足K-V的存取,而且在非多线程的场景下也能保持不错的性能,但是HashMap有一个缺点就是不能保证元素的顺序,相比之下,LinkedHashMap就满足了这点,可以保证元素的插入顺序。
LinkedHashMap的数据结构实现如下图所示:

LinkedHashMap源码及LRU实现原理_第2张图片


LinkedHashMap也是Java中多态思想的一个重要运用,其底层实现可以看作是HashMapLinkedList的结合,使用HashMap来存储数据,使用LinkedList来维护链表的顺序,一定程度上也增加了时间和空间的消耗。

源码解析

相关变量

在LinkedHashMap中有一个重要的成员变量,用来标志元素的排序规则,默认为false。

/**
 * 双向链表的头部(最老的)。
 */
transient LinkedHashMap.Entry head;

/**
 * 双向链表的尾部(最小的)。
 */
transient LinkedHashMap.Entry tail;

/**
 * 用来指定LinkedHashMap的迭代排序方法:访问顺序为true ,插入顺序为false。
 */
final boolean accessOrder;

LinkedHashMap中的节点继承自HashMap.Node,采用的是双向链表的结构,因此支持双向遍历。

static class Entry extends HashMap.Node {
    Entry before, after;
    Entry(int hash, K key, V value, Node next) {
        super(hash, key, value, next);
    }
}

构造方法

LinkedHashMap共有5个构造方法,在不指定成员变量accessOrder作为构造入参时,都被显式的声明为false,这也说明了在默认情况下,LinkedHashMap是按照插入顺序进行排序。
由于继承自HashMap,因此构造方法入参也可以指定初始容量initialCapacity和加载因子loadFactor

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(Map m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

实现原理

HashMap的底层数据结构为哈希表,这种结构的特点为数组+链表或者是数组+红黑树的结构,初始化容量指定的为数组的容量,每一个数组的下标位置被称为一个bucket,每个bucket处的头节点之后为链表或者红黑树,在进行元素查找时可以达到O(1)、O(logN)、O(N)的时间复杂度,具有较高的性能。
LinkedHashMap在添加元素时直接调用的时HashMap的put实现,在HashMap中预留了对节点的后置操作回调函数,如下所示:

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node p) { }

查看HashMap中put方法的源码实现:

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    // ......省略片段
    Node[] tab; Node p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    	// ......省略片段
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 对链表的节点进行后置增强操作
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // 在节点插入之后所做的操作,HashMap中该方法未有任何实现,在LinkedashMap中
    // 实现了该方法,用于处理节点添加后的后置操作,evict该参数默认为true,是否驱逐节点
    afterNodeInsertion(evict);
    return null;
}

// HashMap在链表操作中调用了afterNodeAccess方法,用来在添加元素节点后进行,节点顺序排列
void afterNodeAccess(Node e) { // move node to last
    LinkedHashMap.Entry last;
    // 如果accessOrder为true并且当前元素不是链表的尾结点,将当前节点移动至链表尾部
    if (accessOrder && (last = tail) != e) {
        LinkedHashMap.Entry p =
            (LinkedHashMap.Entry)e, b = p.before, a = p.after;
        // ......省略片段,链表操作
    }
}

查看afterNodeInsertion方法的实现,源码如下:

// 该方法的作用是在新的元素插入后,可能会移除旧的节点
// 因此LinkedHashMap很适合用来做LRU Cache
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry first;
	// evict默认为true,removeEldestEntry在LinkedHashMap中的实现默认为false
    // 在LinkedHashMap中默认不会移除,但是预留了扩展来实现缓存淘汰方案
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        // 移除添加时间最久的节点
        removeNode(hash(key), key, null, false, true);
    }
}

// 该方法是一个可以被继承实现的方法
protected boolean removeEldestEntry(Map.Entry eldest) {
    return false;
}

关于节点的删除操作,查看removeNode方法的具体实现

// 移除节点 movable为true,matchValue为false
final Node removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node[] tab; Node p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        //......省略
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            //......省略
            // LinkedHashMap实现,移除节点后的回调函数
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

查看节点移除后的后置操作

// 移除节点后
void afterNodeRemoval(Node e) { // unlink
    // 临时节点p记录当前节点,a指向p的后一个节点,b指向p的前一个节点
    LinkedHashMap.Entry p =
        (LinkedHashMap.Entry)e, b = p.before, a = p.after;
    // 当前节点移除后,p的前一个、后一个节点都指向null
    p.before = p.after = null;
    
    // 处理head指向
    // 如果前一个结点为null,当前节点被移除,所以head指向当前节点的后一个节点
    if (b == null)
        head = a;
    else
        // 如果前一个节点不为null,当前节点被移除后,当前节点上一个节点指向下一个节点即可
        b.after = a;
    
    // 处理tail指向
    // 如果当前节点的下一个节点为null,说明当前节点为头节点,当前节点被移除,tail指向下一个
    if (a == null)
        tail = b;
    else
        // 当前节点的下一个节点不为null,直接进行节点追加
        a.before = b;
}

LRU实现

在操作系统中,物理内存不可能同时加载所需的所有数据页,只能加载正在或最近要使用的内存页,这也就伴随着页面的更换,页面更换的目标是,尽量替换掉不再使用或者一段时间内不再使用的内存页,要不然会很容易触发缺页中断,该操作代价较大,涉及到从磁盘加载,因此页面更换可不是随便的事情。在内存不够的场景下,会进行内存淘汰的机制,随之也出现了各种淘汰算法,大致可以分为以下两大类:

  • 公平算法:随机算法、FIFO算法、时钟算法。
  • 非公平算法:NRU算法、LRU算法、工作集算法。

LRU即Least Recently Used,最近最少使用算法,当缓存满了,会优先淘汰那些最近最不常访问的数据。在Java中利用LinkedHashMap可以很容易的实现LRU,在一些开源软件方案中也随处可见基于LinkedHashMap实现的LRU方案,如下面两个代码案例:

/**
 * MySQL Driver LRU实现
 */
public class LRUCache extends LinkedHashMap {
    private static final long serialVersionUID = 1L;
    protected int maxElements;

    public LRUCache(int maxSize) {
        super(maxSize, 0.75F, true);
        this.maxElements = maxSize;
    }

    protected boolean removeEldestEntry(Entry eldest) {
        return this.size() > this.maxElements;
    }
}

/**
 * Druid LRU实现
 */
public class LRUCache extends LinkedHashMap {
    private static final long serialVersionUID = 1L;
    private final int maxSize;

    public LRUCache(int maxSize) {
        this(maxSize, 16, 0.75F, false);
    }

    public LRUCache(int maxSize, int initialCapacity, float loadFactor,
                    boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
        this.maxSize = maxSize;
    }

    protected boolean removeEldestEntry(Entry eldest) {
        return this.size() > this.maxSize;
    }
}

以上代码可以看出,实现的代码大同小异。下面使用具体案例来演示使用的过程:

import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class LRUCache extends LinkedHashMap {
    private static final long serialVersionUID = 1L;
    protected int maxElements;

    public LRUCache(int maxSize) {
        super(maxSize, 0.75F, true);
        this.maxElements = maxSize;
    }

    protected boolean removeEldestEntry(Entry eldest) {
        // 当HashMap的size大于预设的最大容纳元素数量maxElements时移除旧的元素
        return this.size() > this.maxElements;
    }
    
    public static void main(String[] args) {
        LRUCache cache = new LRUCache<>(3);
        cache.put("k1", 1);
        cache.put("k2", 2);
        cache.put("k3", 3);
        print(cache);

        cache.get("k3");
        cache.get("k2");
        cache.get("k1");
        print(cache);

        cache.put("k4",4);
        print(cache);
    }

    public static void print(LRUCache cache) {
        cache.forEach((k, v) -> System.out.println(k + " : " + v));
    }
}

输出结果:

k1 : 1
k2 : 2
k3 : 3
    
k3 : 3
k2 : 2
k1 : 1
    
k2 : 2
k1 : 1
k4 : 4

可以看到Cache中最大容纳元素数量为设定数量3,超过3的元素会被丢弃,缓存中的数据也是按照访问顺序进行排序,访问顺序包含put、get两种操作。其工作原理如下图所示:LinkedHashMap源码及LRU实现原理_第3张图片

总结

  • HashMap利用哈希表进行数据存取,其底层实现结构为数组+链表或者数组+红黑树,LinkedHashMap在使用HashMap进行数据存储的过程中,又维护了一个双向链表来维持顺序,通过accessOrder支持链表的双向遍历。
  • 基于LinkedHashMap可以巧妙的实现缓存LRU。既可以按照访问顺序,也可以按照插入顺序进行数据的淘汰。
  • 相比HashMap的访问操作,put、get方法,LinkedHashMap在进行元素访问后都会调用回调函数afterNodeAccess进行元素排序操作,在put元素后还会额外调用afterNodeInsertion回调方法进行后续操作,并且根据removeEldestEntry方法的返回结果判定是否进行旧元素移除,默认不进行删除。

你可能感兴趣的:(Java,java,开发语言)