【图文并茂】讲解HashMap引发的死循环

一场雪ycx

已于 2023-07-14 10:48:44 修改

阅读量8.1k

点赞数 20

分类专栏：数据结构与算法文章标签：链表数据结构 java

于 2020-10-10 10:23:09 首次发布

本文链接：https://blog.csdn.net/yang553566463/article/details/108992081

版权

数据结构与算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

图文并茂-讲解HashMap引发的死循环

官方介绍文档上已经明确说过了，HashMap是线程不安全的，那么为啥会线程不安全？

首先是JDK1.7的HashMap上，在多线程环境下操作HashMap可能引起死循环。

原因是在HashMap扩容时，链表转移后，前后链表顺序倒置（头插法导致），在转移过程中修改了原来链表中节点的引用关系，导致链表结点互相引用，即形成了环，这种情况下，当我们使用get操作获取到环形链表处的数据，就会发生死循环。

在JDK1.8中，同样的前提下并不会引起这个死循环，原因是扩容转移后前后链表顺序不变，保持了之前节点的引用关系。

但是即使1.8不会出现死循环，但是由于put、get方法都没有加同步锁，多线程操作仍是不安全的。

例如，我们无法保证上一秒put的值，下一秒get的时候还是原值，这就是数据不一致的问题，所以线程安全仍无法保证。

那么我们下面就重点讲解死循环的问题，看看它是到底是怎么产生的。

下面我们进入JDK1.7的HashMap源码，看看它是如何扩容的：

Jdk1.7:
void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        //如果旧容量已经达到了最大，将阈值设置为最大值，与1.8相同
        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);
}

resize方法的大致流程如下：

1、旧数组存入oldTable变量，旧容量大小存入oldCapacity变量

2、如果旧容量已经达到了最大，将阈值threshold设置为最大值，并且return，说明无法继续扩容了。与1.8相同

3、根据oldCapacity值创建新结点数组newTable

4、执行transfer方法将旧数据转移到新的哈希表上

5、更新扩容阈值

下面重点来了，我们继续跟进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;
                //如果hashSeed变了，需要重新计算hash值
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                //得到新表中的索引
                int i = indexFor(e.hash, newCapacity);
                //将新节点作为头节点添加到桶中
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
}

1、先获取到新数组的大小

2、遍历旧的HashMap

3、每遍历到一个HashMap中的一个结点数组索引，就对该索引下的链表进行遍历

4、判断链表结点 e 是否需要重新计算hash值

5、计算得到链表结点 e 应该放在数组中的哪个索引处，即索引 i 处

6、将结点 e 以头插法的形式插入该数组索引下

好了，以上就是JDK1.7中HashMap的整个扩容过程。那么，它在多线程环节下是如何产生死循环的呢？

事实上，

造成死循环的关键因素是扩容后链表结点的引用形成了一个环，而形成环的主要代码在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;
                //如果hashSeed变了，需要重新计算hash值
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                //得到新表中的索引
                int i = indexFor(e.hash, newCapacity);
                //将新节点作为头节点添加到桶中
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
}