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
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，然后所有的
正常的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