图解JDK1.7中HashMap头插法扩容造成的死循环问题

最新推荐文章于 2024-08-22 04:30:43 发布
原创 最新推荐文章于 2024-08-22 04:30:43 发布 · 887 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

博客围绕Java扩容展开，先给出扩容源码，接着举例说明。假设两个线程同时扩容并进行数据迁移，线程A完成整个扩容后，线程B继续执行，经三轮循环后形成死循环。

目录

扩容源码

先来看一下扩容的源码

void resize(int newCapacity) {
   
   
  Entry[] oldTable = table;
  int oldCapacity = oldTable.length;
  if (oldCapacity == MAXIMUM_CAPACITY) {
   
   
    threshold = Integer.MAX_VALUE;
    return;
  }

  //根据新的长度创建好的newTable
  Entry[] newTable = new Entry[newCapacity];
  
  // initHashSeedAsNeeded(newCapacity)这个返回值为false
  // 转移
  transfer(newTable, initHashSeedAsNeeded(newCapacity));
  table
最低0.47元/天 解锁文章
HashMap在JDK1.7中多线程并发会出现死循环，超详细图解
qq_57031340的博客
09-13 1730
就是JDK1.7的头插法造成了循环问题，因此在JDK1.8中对HashMap的扩容方法进行了改进，从头插法改成了尾插法。
解析JDK1.7 HashMap 头插法生成的环形链表死循环问题
是狮不是猿
03-25 6244
背景 在JDK1.7中HashMap使用头插法来添加同一位置上的节点,但是在并发的情况下使用HashMap，在进行resize()扩容的过程中，链表可能会形成环状，当在读取HashMap元素的时候会出现死循环，CPU占用标高，服务器崩溃的问题。 扩容前 正常 resize() 后 并发 resize() 形成环状 在下面我会说明是如何生成该环状 正常扩容resize()的过程 以下执行的过程是在同一链表元素的key值rehash后落到同一坐标上为基础 我们需要关注的是HashMap的resize()方
【图解】HashMap1.7 头插法造成死循环的原因
热门推荐
gongsenlin341的博客
01-13 1万+
1.概述 HashMap1.7当中，扩容的时候，采用的是头插法转移结点，在多线程并发的情况下会造成链表死循环的问题。 2.图解 假设有两个线程，线程1和线程2，两个线程进行hashMap的put操作，触发了扩容。 下面是扩容的时候结点转移的关键代码 void transfer(Entry[] newTable) { Entry[] src = table; int newCapacity = newTable.length; for (int j = 0; j <
HashMap死循环问题大讲解（图解）
weixin_73077810的博客
05-18 2763
图解HasmMap死循环的产生及其解决方案
Hashmap jdk1.7死循环问题
weixin_40696225的博客
08-22 194
hashmap是在jdk1.7是数组+链表，通过hash计算出数组下标位置以后，如果同一个位置有多个元素，放在链表中，在多线程插入，并同时扩容的并发环境会出现死循环问题头插入法在维护链表元素的过程中，有一个head指针，指向第一个元素，没有尾部指针（未插入需要维护一个尾部指针，才能快递定位在哪里插入）。举例子：A->...
jdk1.7 HashMap中的致命错误：循环链表
12-21
然而，在JDK1.7版本中，HashMap存在一个严重的问题，即“循环链表”（Looping List），这可能导致在多线程环境下性能急剧下降，甚至引发死循环。本文将深入探讨这个问题及其解决方案。 首先，我们来看看JDK1.7 ...
HashMap在JDK1.7版本头插法实现解析
weixin_41563161的博客
03-23 1799
HashMap在JDK1.7版本头插法实现解析 先解释下何为头插法。大家都知道HashMap在JDK1.7版本的数据结构为数组+链表这样的形式。而头插法说的就是在往HashMap里面put元素时，此时新增在链表上元素的位置为链表头部，也就是数组桶位上的那个位置，故名头插法。 直接上源码，看看JDK1.7的元素插入代码实现： publ...
5张图讲明白JDK1.7下的HashMap死循环（原理+实战)
xvktdmjg的博客
03-21 1916
目录 情景再现 网络上很多文章说HashMap死循环都是理论分析，其一是没有自己实验过，甚至给出的实验程序都是错误的，不能再现死循环的BUG，其二是给出的示意图不够详细，很多细节忽略了让人难以理解，本文在前人总结的基础上摸索出了实现死循环的方法，记录成文。 死循环原因 我们首先思考一下在什么样的情况下HashMap会死循环，死循环的原因不外乎是在多线程的同时扩容，在JDK 1.7的HashMap中，当hash冲突时，采用头插法拉链表，所谓头插法，即在每次都在链表头部（即桶中）插入最后添加的数据 当触发扩容
HashMap 1.7 为什么不安全 头插法为什么会死循环？
weixin_53651170的博客
03-13 2343
jdk1.7版本HashMap为什么会出现死循环问题，用简单易懂的解释告诉你
jdk1.7 hashmap死循环
weixin_48913290的博客
09-11 1346
HashMap死循环只发生在JDK1.7版本中，主要原因是JDK1.7中的HashMap，在头插法 加 链表 加 多线程并发 加 扩容这几个情形累加到一起就会形成死循环。多线程环境下建议采用ConcurrentHashMap替代。
多图详解的HashMap1.7扩容死循环
马疯蜗的博客
07-24 3296
HashMap扩容过程详解一、1.7HashMap扩容死循环1.产生原因二、1.8HashMap扩容流程 一、1.7HashMap扩容死循环 1.产生原因 1.7HashMap在高并发场景下，会发生扩容链表死循环问题！ 二、1.8HashMap扩容流程
HashMap1.7死循环问题
weixin_44150634的博客
04-01 1159
HashMap1.7死循环问题
【笔记】HashMap的头插死循环问题
zoey_peak的博客
06-23 758
假设T1得到时间片先完成了扩容，然后通过新的hash函数变到了新位置（这里刚好还是1），然后用不带头结点的头插法把原来位置的元素挪过来，因为头插法所以顺序变反了（735变成357），但T2还是e指针指着7，next指针指着5（下图是T2的e）在轮到T2扩容的时候，e.next=newTable[i], newTable[i] = e;虽然JDK1.8改成尾插法了，不会死循环，但是因为put和get都没加同步锁，仍是线程不安全的。此时T1、T2都指着同一个位置，都是e指针指着7，next指针指着5，
jdk1.7下HashMap的头插法问题
乐乐的博客
12-30 2993
jdk1.7，hashmap才用的是头插法，虽然hashmap并不是线程安全的容器，但是在并发情况下，使用hashmap会带来一个问题： 并发情况下，如果插入元素的两个线程都调用了rehash方法，即扩容方法，会导致链表成环的问题。 hashmap成环原因的代码出现在transfer代码中，也就是扩容之后的数据迁移部分（如下）： /** * Transfers all entries from current table to newTable. */ void transfer
面试官:说说java1.7HashMap头插法导致死循环的问题
weixin_46633487的博客
05-20 5026
HashMap头插法会导致死循环问题 大家天天都说Java1.7Hashmap头插法会导致死循环问题 可是大家知道为什么嘛？ 下面我们来详细讲解一下全过程: 首先hashmap头插法导致死循环问题是在多线程并发环境下 2个线程并发扩容 而且旧的链表扩容到新的链表的数组是相同的情况下会导致死循环问题。 比如 要弄清除原理 首先我们需要看懂扩容的过程 上源码，标注了主要的序号 头插法单个线程进行扩容 下面步骤我们都标了序号 第一步 首先找到第一个头 2. 3. 4. 第二次循环 1. 2. 3.
HashMap多线程扩容导致死循环解析（JDK1.7）
qq_51902025的博客
01-16 779
由于头插法的原因，再次执行头插法的时候会将原来的链表顺序反过来，所以当第一个线程执行完扩容之后会将顺序从。最后由于e等于null，退出循环，当下次遍历到该元素时就会进入死循环。1->2->3 到 3->2->1。线程二第一次执行插入结束后。线程二准备第二次循环结束后。线程二第二次执行插入结束后。线程二准备第二次循环结束后。线程二第三次执行插入结束后。线程二准备第三次循环结束后。
HashMap1.7 头插法造成死循环的原因
li-zhang-yu的博客
05-05 2330
一：HashMap1.7 头插法造成死循环的原因
【图文并茂】讲解HashMap引发的死循环
yang553566463的博客
10-10 8906
官方介绍文档上已经明确说过了，HashMap是线程不安全的，那么为啥会线程不安全？首先是JDK1.7的HashMap上，在多线程环境下操作HashMap可能引起死循环。原因是在HashMap扩容时，链表转移后，前后链表顺序倒置（头插法导致），在转移过程中修改了原来链表中节点的引用关系，导致链表结点互相引用，即形成了环，这种情况下，当我们使用get操作获取到环形链表处的数据，就会发生死循环。在JDK1.8中，同样的前提下并不会引起这个死循环，原因是扩容转移后前后链表顺序不变，保持了之前节点的引用关系。但是即使
java hashmap1.7 扩容过程详细解释
最新发布
10-21
<think>我们正在讨论Java HashMap 1.7版本扩容过程的详细解释。注意，用户要求详细解释扩容过程，并且我们有一些引用材料可以参考。 引用[1][2][3][4][5]都涉及到HashMap 1.7的扩容，特别是引用[3][4][5]详细描述了扩容过程以及多线程下产生死循环的问题。 根据引用材料，我们可以总结扩容过程如下： 1. 触发条件：当元素数量达到阈值（threshold）并且当前桶中已经有元素（即发生哈希碰撞）时，进行扩容（引用[2]）。 2. 扩容操作：创建一个新的Entry数组，大小为原数组的2倍，然后将原有Entry数组中的元素重新计算位置（重新哈希）并转移到新数组中（引用[3][4]）。 3. 转移过程：使用transfer方法，遍历原数组的每个桶（即每个链表），对每个链表进行遍历，将每个节点重新计算在新数组中的位置（引用[3][4]）。 4. 重新哈希：计算每个节点在新数组中的索引（indexFor方法），然后使用头插法将节点插入新数组的对应位置（引用[3][5]）。 关键点： - 头插法：在转移链表节点时，采用头插法。即每次将节点插入到新数组对应桶的头部。这会导致链表顺序反转（引用[5]）。 - 多线程问题：头插法在并发扩容时可能导致环形链表，从而在后续操作时造成死循环（引用[3][4][5]）。 详细步骤（单线程下）： 1. 根据原数组长度计算新数组长度（原数组长度*2）。 2. 创建新数组。 3. 遍历原数组的每个桶（每个链表）： for (Entry<K,V> e : table) { while (e != null) { // 步骤a：记录下一个节点 Entry<K,V> next = e.next; // 如果需要重新哈希，则重新计算哈希值（rehash默认为false，一般不需要） if (rehash) { e.hash = (e.key == null) ? 0 : hash(e.key); } // 步骤b：重新计算该节点在新数组中的桶下标（索引） int i = indexFor(e.hash, newCapacity); // 步骤c：头插法 e.next = newTable[i]; // 将当前节点的next指向新数组中该桶的第一个节点（可能为null） newTable[i] = e; // 将新数组中该桶的头节点设为当前节点 e = next; // 处理下一个节点 } } 注意：头插法会导致链表顺序反转。例如，原链表为A->B->C，转移后在新数组中变为C->B->A。 多线程环境下为什么会产生环形链表？ 假设有两个线程同时进行扩容，原链表为：A->B->C（指向null）。 线程1执行到`Entry<K,V> next = e.next;`后挂起，此时线程1记录e=A, next=B。 线程2执行完整个转移过程，新数组中该桶的链表变为C->B->A（即头插法反转）。 然后线程1继续执行，此时： e=A, next=B（线程1记录的） 重新计算A在新数组中的位置（假设仍在同一位置），然后执行： e.next = newTable[i]; // 此时newTable[i]是线程2已经转移后的头节点（即C，但是注意线程2已经反转了链表，所以原链表A->B->C变为C->B->A，而线程1执行时，线程2已经将新数组的该桶设置为C，并且C->B->A） 因此A.next指向了C。 然后newTable[i]=A，这样新数组中该桶的头节点变为A，而A.next=C，而C后面连接的是B->A（因为线程2的结果是C->B->A，而线程1又将A插入到头部，所以形成了环？） 具体形成环的过程（详细）： 初始状态：链表为 A -> B -> C -> null 线程2成功扩容后，新数组中的链表为 C -> B -> A -> null（因为头插法反转） 线程1此时继续执行（因为线程1已经记录了e=A, next=B）： 第一步：处理节点A e = A, next = B 重新计算A的索引（假设和C在同一桶） e.next = newTable[i] -> 此时newTable[i]是C（因为线程2已经将C放在该桶的头节点），所以A.next = C newTable[i] = A -> 现在该桶的头节点变成了A，而A指向C，而C在之前（线程2处理的结果）指向B，B指向A（因为线程2处理完后，B.next=A，而线程1将A.next改为指向C，但实际上线程2的B.next=A，所以现在有：A->C->B->A，形成一个环） 因此，当后续对该桶进行遍历时，就会陷入死循环。 注意：引用[3][4][5]都详细描述了这个问题。 现在我们根据用户的请求，详细解释扩容过程（重点在单线程下的正常扩容过程，并说明多线程下问题的原因）。 回答结构： 1. 触发扩容的条件 2. 扩容的步骤（重点在transfer方法） 3. 头插法的特点及其影响（反转链表） 4. 多线程下产生问题的原因（简要描述） 注意：用户要求详细解释扩容过程，所以重点放在步骤上。 最后，生成相关问题。 </think>### Java HashMap 1.7 扩容过程详解 #### 1. **触发条件** 当元素数量达到阈值且目标桶非空时触发扩容： ```java if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); // 扩容为原表2倍[^2] hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); ``` - **阈值计算**：$threshold = capacity \times loadFactor$（负载因子默认 0.75） - **扩容幅度**：新容量 = 旧容量 × 2 --- #### 2. **核心步骤：`resize()` 与 `transfer()` **(1) 创建新数组** ```java void resize(int newCapacity) { Entry[] newTable = new Entry[newCapacity]; transfer(newTable, rehash); // 数据迁移 table = newTable; // 替换原数组 threshold = (int)(newCapacity * loadFactor); // 更新阈值 } ``` **(2) `transfer()` 数据迁移** ```java 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; // 保存下一节点 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; // 处理下一节点 } } } ``` --- #### 3. **关键操作解析** 1. **头插法（链表反转）** - 操作顺序：`e.next = newTable[i]` → `newTable[i] = e` - 效果：原链表 `A→B→C` 迁移后变为 `C→B→A`[^5] - 示例： ```mermaid graph LR 旧桶-->|A→B→C| 迁移 迁移-->|步骤1| e.next=null 迁移-->|步骤2| newTable[i]=A 迁移-->|步骤3| e=B; e.next=A --> newTable[i]=B --> C=B.next 迁移-->|结果| C→B→A ``` 2. **索引重定位** - 计算新下标：$i = hash \& (newCapacity-1)$ - 扩容后节点可能分配到新位置： $$ newIndex = oldIndex \quad or \quad oldIndex + oldCapacity $$ --- #### 4. **多线程死锁问题（环形链表）** 并发扩容时，头插法+链表截断会导致环形链表： 1. **初始状态**：桶链表为 `A → B → null` 2. **线程1挂起**：执行 `next = e.next` 后记录 `e=A, next=B` 3. **线程2完成扩容**：新链表变为 `B → A → null` 4. **线程1继续执行**： ```java e.next = newTable[i]; // A.next = B（此时B.next已指向A） newTable[i] = e; // 桶头变为A e = next; // e=B ``` 结果形成环形链表 `A → B → A`[^3][^4]，后续操作陷入死循环。 --- #### 5. **与JDK 1.8的区别** | 特性 | JDK 1.7 | JDK 1.8 | |--------------|-----------------------|-----------------------| | **插入方式** | 头插法（反转链表） | 尾插法（保持顺序） | | **数据结构** | 数组+链表 | 数组+链表/红黑树 | | **线程安全** | 并发扩容可能死锁[^1] | 优化尾插法避免环形链表 | > 示例：JDK 1.7的迁移过程源码见引用[3][4][5]，多线程问题图解见引用[3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值