HashMap源码解析及1.7中的死循环问题
HashMap是一个以键值对形式存储数据的数据结构，键有且仅可以有一个为null，在1.8之前采用了数组+链表的数据结构，之后是数组+链表+红黑树。HashMap是多线程不安全的，HashTable是多线程安全的，但是HashTable在并发环境下效率较低，因此可以考虑使用ConcurrentHashMap来提高并发能力。
JDK1.7中的HashMap
由于HashMap在1.7及之前使用头插法，会导致多线程环境下可能造成死循环问题。
接下来一起看一下1.7中HashMap的put(K key, V value)方法:
public V put(K key, V value) {
if (table == EMPTY_TABLE) {// 判断是否初始化并初始化HashMap
inflateTable(threshold);// 初始化table
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
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;
}
1.7中的put方法大致流程是根据key的hash值计算要存储的索引位置i，若在索引位置i处的链表（Entry）已存在该key，则替换并返回旧值，若否则使用addEntry()方法添加新的Entry。接下来看一下addEntry方法方法如何添加链表：
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);
}
// 添加Entry
createEntry(hash, key, value, bucketIndex);
}
这里我们先留意一下resize(2 * table.length)这个重新扩容HashMap的方法，先来看一下createEntry()方法：
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++;
}
在createEntry方法中，我们看到取出了索引位置bucketIndex（也就是刚才hash运算得出的索引位置i）的Entry e，然后使用Entry的构造方法new了一个新的Entry，并将它重新设置到索引位置上，我们来一起看一下这个构造方法：
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;// 设置下一个节点
key = k;
hash = h;
}
在这个被调用的构造方法中，传入的e（原索引位置的链表）被设置成了新Entry的next节点，也就是说：新节点会在原链表的头部插入。如下图所示：
到这里讲完了HashMap的头插法，下面我们来一起看一下这么做会有什么问题。还记得上面说的addEntry()方法中用来扩容的resize()方法，接下来一起看一下这个方法内部的逻辑：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
该方法要做的其实就是扩容当前的HashMap。我们知道HashMap的结构其实是数组，要扩容就避免不了的开辟一个新的空间存储新的更大容量的数组，并给原数组内的元素（Entry）重新在新数组中找到安放的位置。而resize()中调用transfer()方法的目的就是如此：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;//位置1
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];// 位置2 头插
newTable[i] = e;
e = next;
}
}
}
transfer()的逻辑大致为将每个Entry根据新的容量进行hash运算计算出新的存储位置，并采用头插法的方式插入（e.next = newTable[i]）。这样会有什么问题呢？
假设有两个线程A和B在不停的往一个HashMap中插入元素，在濒临阈值的某一时刻，线程A执行到了上面代码的位置1处，获取了e.next, 即e的下一个节点，如下图中的节点f ：
这时线程B抢到了CPU执行权，线程A被挂起，线程B开始进行HashMap的扩容工作，假设e和f节点在扩容后还处在同一索引位置处，而我们又知道每个Entry在插入时采用的是头插法，那么扩容后如下图所示：
这时f变成了e的上一个节点，也就是说f.next就是e节点。这时线程A从位置1继续执行下面这几行代码，也就是说线程A获取了newTable索引i位置处的链表，并将e节点又从头部插入：
...
e.next = newTable[i];
newTable[i] = e;
e = next;
...
那么结构又变成了现在这样：
这样问题就显而易见了，在循环中，e的下一个节点是f，而在新的table中f的下一个节点又是e，这样就变成了e指向f，而f也指向e，即变成了一个闭环。
以上就是HashMap在1.7中的问题，接下来我们来看一下在1.8中HashMap的结构是怎样的。
1.8中的HashMap
Fields
我们先来看一些HashMap的属性：
// 0000 0001 --> 0001 0000 即默认容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转化为红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转化为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 转化为红黑树的最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
构造方法
HashMap一共有四个构造方法，分别是无参构造，入参为容量大小的有参构造，入参为容量和负载因子的有参构造，入参为Map类型的有参构造。与1.7中不同的是，无参构造的HashMap在1.8中在创建时并不会对Map进行初始化，而是使用时再初始化。
// 1.7中的构造方法
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
// 1.8中的构造方法
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
内部类
这里需要注意两个内部类：Node和TreeNode。
-
Node：类似1.7中的Entry，主要用来做链表结构的实现：
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; ... } -
TreeNode：HashMap中的链表在满足一定条件后会转换为红黑树，这时就需要TreeNode来构建这种数据结构：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; }
put()和get()
向Map中添加元素——put(K, V)
向HashMap中添加元素主要使用的是put方法，而put内部其实是调用了putVal方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
这里需要注意的是传入putVal的第一个参数使用hash()方法计算了key的哈希值，我们来一起看一下这个hash()方法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里可以看到，key在为null时返回的哈希值为0。key不为null时，则由key的hashCode和key的hashCode的高16位进行异或运算（其实就是高16位与低16位的异或运算）。这个hash()方法的返回值主要用于后续计算元素要存储的数组下标，使用这样的异或运算保证了hashCode的值有一位发生改变，那么整个hash值就会发生改变，从而减小哈希碰撞出现的概率。
接下来一起看向HashMap中添加与元素的putVal()：
-
在位置1（代码在下面）处判断当前table是否被初始化，然后使用resize()方法初始化
-
从位置2可以看到，程序用刚才hash(key)得到的hash值和当前table长度-1进行与运算计算要元素要存放的位置下标i。那么问题来了：为什么要使用长度-1进行与运算呢？
- 假设table长度为16，那它的二进制就是：【0001 0000】，那么-1之后就变成了【0000 1111】，这样在与hashCode与运算时确保每一位都有可能为真(1)，从而合理的得出15以内的数组下标。
-
所以这时我们就知道位置2的判断逻辑了：首先使用与运算计算出元素要存储位置的数组下标，并将该下标的值赋值给p，然后判断是否为空，为空就使用newNode()方法在该位置新建一个链表（Node）
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) { return new Node<>(hash, key, value, next); } -
若上面的if判断不成立，代码将会从位置3进入else块中。在位置4可以看到，程序采用hash值是否相等、key是否相等(==)、equals判断是否相等三个方面来确立key和原i位置元素的相等性，若相等则将p赋值给e（位置4）
-
若p的类型是一个红黑树（位置5），则使用**putTreeVal()**向该树中添加元素
-
若非上述情况，则进入位置6的for循环，然后在位置7判断p的下一个节点是否为空，若为空则newNode()新建一个Node称为p的下一个节点（往p后面添加一个节点，这里是尾插法）
-
位置8处判断当前长度是否大于树化的阈值（8），然后执行链表转换为红黑树的方法treeifyBin()， 一起来看一下这个方法：
final void treeifyBin(Node<K,V>[] tab, int hash) { ... if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) ... }可以看到有一个隐含条件，就是当数组长度小于MIN_TREEIFY_CAPACITY也就是64时，链表是不会转换成红黑树的
-
接着继续向下遍历，在位置9处判断下个节点的相等性，若相等就返回，不相等则继续遍历（p=e）
-
位置10，如果链表中存在重复的key，就替换并返回旧值。这个8-9环节用一句话总结就是：新元素在链表中向下寻找，如果遇到有重复的key就插入并返回旧值，如果没有就在链表的尾部插入一个新的Node
-
位置11之后的步骤：增加修改次数，并判断当前阈值，超过了就扩容。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)// 位置1
n = (tab = resize()).length;// 初始化table
if ((p = tab[i = (n - 1) & hash]) == null)// 位置2
tab[i] = newNode(hash, key, value, null);// 在i位置初始化链表
else {// 位置3
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;// 位置4
else if (p instanceof TreeNode)// 位置5
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {// 位置6
if ((e = p.next) == null) {// 位置7
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // 位置8
treeifyBin(tab, hash);// 链表转红黑树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))//位置9
break;
p = e;
}
}
if (e != null) { // 位置10
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 位置11
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
查找Map中的元素——get(K)
get(Object key)方法用于获取HashMap中的元素，代码如下：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
这里还是先使用了hash(key)计算了key的哈希值，接着调用getNode方法获取元素：
- 这里先进入位置1，判断table不为空且要查询的索引位置位置的链表不为null则进入if中
- 检查table索引位置链表的头结点first是否为要找的key（位置2），如果是就返回first节点
- 如果不是沿着链表（位置4）或红黑树（位置3）继续向下找，找不到就返回null，找到就返回要找的节点。
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {// 位置1
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))// 位置2
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)// 位置3 红黑树查找
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {// 位置4 链表查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
