LinkedHashMap源码分析

前言：LinkedHashMap继承HashMap，所以它是线程不安全的，但是它有序，下面就让我们来对其内部原理进行分析。

注：本文jdk源码版本为jdk1.8.0_172

---

1.LinkedHashMap介绍

LinkedHashMap底层数据结构为双向链表，能保证元素按照插入顺序访问，也能以访问顺序访问，可以用来实现LRU策略缓存。

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>

可以把LinkedHashMap看成LinkedList+HashMap。由于继承HashMap所以其默认容量为16，扩容因子为0.75，非同步，允许[key,value]为null。

2.具体源码分析

先看LinkedHashMap的重要属性

// Entry继承HashMap的Node
static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}
/**
 * The head (eldest) of the doubly linked list.
 */
// 旧数据放在head节点 
transient LinkedHashMap.Entry<K,V> head;

/**
 * The tail (youngest) of the doubly linked list.
 */
// 新数据放在tail节点
transient LinkedHashMap.Entry<K,V> tail;

/**
 * The iteration ordering method for this linked hash map: <tt>true</tt>
 * for access-order, <tt>false</tt> for insertion-order.
 *
 * @serial
 */
// false-按插入顺序存储数据 true-按访问顺序存储数据
final boolean accessOrder;

分析：

从源码上可知以下几点：

#1.LinkedHashMap的底层数据结构继承至HashMap的Node，并且其内部存储了前驱和后继节点。

#2.LinkedHashMap通过accessOrder来控制元素的相关顺序，false-按插入顺序存储数据，true-按访问顺序存储数据，默认为false。

构造函数：

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

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

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

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

    public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

分析：

从构造函数可以，accessOrder默认为false，当然也可自定义。

LinkedHashMap的实现比较精妙，很多方法都是通过HashMap中留的钩子（Hook），直接实现这些Hook就可以实现对应的功能，而不需要重写诸如put方法，因此在LinkedHashMap的源码中并未发现put方法，这里分析其实现的钩子方法。

afterNodeAccess(Node<K,V> e)，主要在执行put方法并且已存在元素时进行调用，如果accessOrder为true，会把访问到的元素移动到双向链表的末尾。

void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        // 如果accessOrder为true，并且访问的节点不是尾节点
        if (accessOrder && (last = tail) != e) {
            // 取出前驱和后继节点
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            // p的前向节点为空，则将a赋值给头节点
            if (b == null)
                head = a;
            else
                // 这里其实就是把p节点从链表中移除
                b.after = a;
            // 构建双向链表
            if (a != null)
                a.before = b;
            else
                last = b;
           // 把p节点放到双向链表尾
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            // 尾节点为p
            tail = p;
            // 修改次数自增
            ++modCount;
            // 对于双向链表，画图可以很好理解
        }
    }

分析：

该函数会在调用put方法出现覆盖key操作时调用，该方法主要作用就是将访问的节点移动到双向链表的末尾，但是有附加条件accessOrder必须为true，否则该操作失效。

afterNodeInsertion(boolean evict)：该方法会在插入节点后被调用。

void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    // evict 驱逐的意思
    // 如果evict为true，其头节点不为空，其确定移除最老元素
    // removeEldestEntry默认返回为false，也就是不删除元素
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

分析：

该函数的主要作用就是判断是否需要移除最老的元素，但是需要我们重写removeEldestEntry方法才能实现，因为该方法默认返回false，即不删除。

afterNodeRemoval(Node<K,V> e)：该方法会在节点被remove后调用。

void afterNodeRemoval(Node<K,V> e) { // unlink
    // 取出其前驱和后继节点
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 把节点从双向链表中删除
    p.before = p.after = null;
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

分析：

该函数为典型的将双向链表的节点从链表中remove掉，逻辑还是比较简单的，理解应该不难。

get方法：

public V get(Object key) {
    Node<K,V> e;
    // 通过getNode方法取出节点，如果为null则直接返回null
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 如果accessOrder为true，则需要把节点移动到链表末尾
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

分析：

通过getNode方法获取元素，该方法在HashMap中（后续会对jdk1.8的HashMap做具体分析），从这里也可以看出LinkedHashMap设计的精妙之处。

afterNodeAccess方法前面已经分析过了，将节点移动至双向链表的尾部。

LinkedHashMap如何实现按元素插入顺序遍历元素的，具体原理如下：

// newNode函数会在put操作时被调用，LinkedHashMap重写了HashMap的newNode方法
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    // 创建节点
    LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<K,V>(hash, key, value, e);
    // 将新节点加入链表尾
    linkNodeLast(p);
    return p;
}

   private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    // 取出链表尾
    LinkedHashMap.Entry<K,V> last = tail;
    // 更新链表尾部元素
    tail = p;
    // 构建双向链表
    if (last == null)
        head = p;
    else {
        p.before = last;
        last.after = p;
    }
}

分析：

由于LinkedHashMap重写了newNode方法，在创建新的节点的时候，就会将节点挂在现有节点的尾部，从而实现按插入顺序访问元素。

而按照访问顺序遍历元素是基于LRU算法（最近最少使用）进行遍历。

3.总结

LinkedHashMap继承HashMap并实现了HashMap中预留的钩子函数，因此不必重写HashMap的很多方法，设计非常巧妙。

#1.LinkedHashMap默认容量为16，扩容因子默认为0.75，非同步，允许[key,value]为null。

#2.LinkedHashMap底层数据结构为双向链表，可以看成是LinkedList+HashMap。

#3.如果accessOrder为false，则可以按插入元素的顺序遍历元素，如果accessOrder为true，则可以按访问顺序遍历元素。

---

by Shawn Chen，2019.09.14日，晚。