JDK1.7 HashMap源码剖析，循环链表是如何产生的

Map 这样的 Key Value 在软件开发中是非常经典的结构，常用于在内存中存放数据。众所周知 HashMap 底层是基于 数组 + 链表 组成的，不过在 JDK1.7 和 1.8 中具体实现稍有不同。

今天我们只讲解JDK1.7版本的HashMap。

1、HashMap的数据结构图

是一个数组+链表结构

2、HashMap成员变量

/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 16;

/**
 * The maximum capacity, used if a higher value is implicitly specified
 * by either of the constructors with arguments.
 * MUST be a power of two <= 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry<K,V>[] table;

/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

/**
 * The next size value at which to resize (capacity * load factor).
 * @serial
 */
int threshold;

/**
 * The load factor for the hash table.
 *
 * @serial
 */
final float loadFactor;

这是 HashMap 中比较核心的几个成员变量；看看分别是什么意思？

① DEFAULT_INITIAL_CAPACITY ：初始化桶大小（16），因为底层是数组，所以这是数组默认的大小。

② MAXIMUM_CAPACITY ：桶最大值。

③ DEFAULT_LOAD_FACTOR ：默认的负载因子（0.75）

④ table：真正存放数据的数组。

⑤ size：map中存放的键值对的数量。

⑥ threshold：resize扩容时的阈值。

⑦ loadFactor：负载因子，可在初始化时显式指定。

HashMap 的构造函数可以指定参数也可以无参。

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
    table = new Entry[DEFAULT_INITIAL_CAPACITY];
    init();
}
    
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);

    // Find a power of 2 >= initialCapacity
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;

    this.loadFactor = loadFactor;
    threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    useAltHashing = sun.misc.VM.isBooted() &&
            (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    init();
}

默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。

因此通常建议能提前预估 HashMap 的大小最好，尽量的减少扩容带来的性能损耗。

3、Entry类

根据代码可以看到真正存放数据的是：transient Entry<K,V>[] table，这个数组，那么它又是如何定义的呢？

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    int hash;

    /**
     * Creates new entry.
     */
    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }
    
    ......

}

Entry 是 HashMap 中的一个内部类，从他的成员变量很容易看出：
① key 就是写入时的键。

② value 自然就是值。

③ 开始的时候就提到 HashMap 是由数组和链表组成，所以这个 next 就是用于实现链表结构。

④ hash 存放的是当前 key 的 hashcode。

知晓了基本结构，那来看看其中重要的put、get方法。

4、put 方法

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

① 如果 key 为空，则 put 一个空值进去。

② 根据 key 计算出 hashcode。

③ 根据计算出的 hashcode 定位出所在桶。

④ 如果桶是一个链表则需要遍历判断里面的 hashcode、key 是否和传入 key 相等，如果相等则进行覆盖，并返回原来的值。

⑤ 如果桶是空的，说明当前位置没有数据存入；新增一个 Entry 对象写入当前位置。

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

① 当调用 addEntry 写入 Entry 时需要判断是否需要扩容。

② 如果需要就进行两倍扩充，并将当前的 key 重新 hash 并定位。

③ 而在 createEntry 中会将当前位置的桶传入到新建的桶中，如果当前桶有值就会在该位置形成链表。新new的Entry会加到链表的头部。

5、get 方法

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

final Entry<K,V> getEntry(Object key) {
    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

① 首先也是根据 key 计算出 hashcode，然后定位到具体的桶中。

② 判断该位置是否为链表。

③ 不是链表就根据 key、key 的 hashcode 是否相等来返回值。

④ 为链表则需要遍历直到 key 及 hashcode 相等时候就返回值。

⑤ 啥都没取到就直接返回 null 。

6、并发场景下出现死循环

多线程同时put时，如果同时调用了resize操作，可能会导致循环链表产生，进而使得后面get的时候，会死循环。下面详细阐述循环链表如何形成的。

resize函数
数组扩容函数，主要的功能就是创建扩容后的新数组，并且将调用transfer函数将旧数组中的元素迁移到新的数组。

void resize(int newCapacity) {
   Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
	//创建一个新的Hash Table
    Entry[] newTable = new Entry[newCapacity];
    //将Old Hash Table上的数据迁移到New Hash Table上
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

transfer函数
transfer逻辑其实也简单，遍历旧数组，将旧数组元素通过头插法的方式，迁移到新数组的对应位置问题出就出在头插法。

void transfer(Entry[] newTable) {
 	//src旧数组
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            do {
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);//由于是链表，所以是个循环过程
        }
    }
}

static int indexFor(int h, int length) {
    return h & (length-1);
}

下面举个实际例子：
① 我假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。
② 最上面的是old hash 表，其中的Hash表的size=2, 加载阈值为2∗0.75=1，所以key = 3, 7, 5，在mod 2以后都冲突在table[1]这里了。
③ 接下来的三个步骤是Hash表 resize成4，然后所有的<key,value> 重新rehash的过程

正常的Rehash的过程

并发下的Rehash
1）假设我们有两个线程，用红色和浅蓝色标注了一下。

我们再回头看一下transfer代码中的这个细节：

do {
   Entry<K,V> next = e.next; //假设线程一执行到这里就被调度挂起了
    int i = indexFor(e.hash, newCapacity);
    e.next = newTable[i];
    newTable[i] = e;
    e = next;
} while (e != null);

而我们的线程二执行完成了。于是我们有下面的这个样子。

注意，因为Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。我们可以看到链表的顺序被反转了。

2）线程一被调度回来执行

先是执行 newTalbe[i] = e；然后是e = next，导致了e指向了key(7)，而下一次循环的next = e.next导致了next指向了key(3)

3）一切安好

线程一接着工作。把key(7)摘下来，放到newTable[i]的第一个，然后把e和next往下移。

4）环形链表出现

e.next = newTable[i] 导致 key(3).next 指向了 key(7)

注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。

于是，当我们的线程一调用到，HashTable.get(11)时，悲剧就出现了Infinite Loop。

有人把这个问题报给了Sun，不过Sun不认为这是一个问题。因为HashMap本来就不支持并发，要并发就用ConcurrentHashmap。

这个循环链表问题只存在于JDK1.7中，在JDK1.8中使用了不同的扩容实现方式，所以不会出现这种情况。JDK1.8中HashMap是如何实现的我们后续讲解。

欢迎小伙伴们留言交流~~
浏览更多文章可关注微信公众号：diggkr