HashMap并发异常小记

最新推荐文章于 2025-06-03 19:06:05 发布
原创 最新推荐文章于 2025-06-03 19:06:05 发布 · 4.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hashmap #并发 #异常 #java

Caused by: java.lang.ClassCastException: java.util.HashMap$Node cannot be cast to java.util.HashMap$TreeNode
at java.util.HashMap$TreeNode.moveRootToFront(HashMap.java:1819)
at java.util.HashMap$TreeNode.treeify(HashMap.java:1936)
at java.util.HashMap.treeifyBin(HashMap.java:771)
at java.util.HashMap.putVal(HashMap.java:643)

at java.util.HashMap.put(HashMap.java:611)

如图：


原因是在并行流中put了HashMap


Java 1.8 hashMap 并发put 的问题 java.util.HashMap$Node cannot be cast to java.util.HashMap$TreeNode
悟已往之不谏，知来者之可追
05-27 4833
报错 Caused by: java.lang.ClassCastException: java.util.HashMap$Node cannot be cast to java.util.HashMap$TreeNode at java.util.HashMap$TreeNode.moveRootToFront(HashMap.java:1835) at java.util.HashMap$TreeNode.treeify(HashMap.java:1951)
20、HashMap并发情况下出现线程安全问题
Garry
05-29 526
一、目标 创建一个HashMap，创建两个线程，每个线程向map中存储50万条key值不一样的数据，最终map中应该存在100万条数据。 二、代码 package com.zjl.study.多线程.ConcurrentHashMap; import java.util.HashMap; import java.util.Map; /** * Created by zjl 2022/5/29 **/ public class ConcurrentHashMapDemo { public sta
【HashMap并发修改异常】(3)
2401_83601703的博客
04-19 817
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优面试真题：《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
Java避坑指南：深度解析HashMap并发修改异常及解决方案
MalinaBaby的博客
06-03 854
深入剖析Java中令人头疼的ConcurrentModificationException异常，通过。
【HashMap并发修改异常】，2024年最新springbootoauth2视频
2401_84140580的博客
04-11 924
在系统设计中，快速失效系统一种可以立即报告任何可能表明故障的情况的系统。快速失效系统通常设计用于停止正常操作，而不是试图继续可能存在缺陷的过程。这种设计通常会在操作中的多个点检查系统的状态，因此可以及早检测到任何故障。快速失败模块的职责是检测错误，然后让系统的下一个最高级别处理错误。其实就是在做系统设计的时候先考虑异常情况，一旦发生异常，直接停止并上报。
HashMap常见并发问题
waterystone的专栏
03-04 1487
HashMap常见并发问题
jdk7下HashMap的扩容和链表死循环发生的场景
Muywan的博客
11-29 675
上一篇中写了个人对jdk7下HashMap的一些浅显的理解。https://blog.csdn.net/weixin_42769637/article/details/103235821。在这里接着上一篇学习扩容和链表循环发生的场景。 HashMap的数组长度是不变的，例如是16，虽然有hash算法和indexFor方法减少哈希冲突的几率，但是存入的数据量增大的时候，哈希冲突的几率也会越来越高。虽...
jdk1.7HashMap并发扩容发生死循环源码详解
MrArgus的博客
03-25 458
jdk1.7HashMap并发扩容发生死循环源码详解
HashMap在并发下可能出现的问题分析
KHOST的博客
06-07 777
我们都知道，HashMap在并发环境下使用可能出现问题，但是具体表现，以及为什么出现并发问题， 可能并不是所有人都了解，这篇文章记录一下HashMap在多线程环境下可能出现的问题以及如何避免。 在分析HashMap的并发问题前，先简单了解HashMap的put和get基本操作是如何实现的。 1.HashMap的put和get操作 大家知道HashMap内部实现是通过拉链法解决哈希冲突的，也就...
HashMap并发扩容死循环问题
tomorrow_shoe的博客
04-30 750
HashMap没有使用考虑并发问题，必然是线程不安全的。 HashMap1.7每一个桶使用的是单向链表实现。而扩容采取的是头插法。 1.什么是头插法？ 链表反转的迭代写法就是经典的头插法 例如链表：1——>2 设反转后为：reverse=null; 那么依次取链表的节点插入反转后的头部，并把当前节点赋给resvese就是头插法。 下面是简要代码： class ListNode { ... public ListNode reverseNode(ListNode root){ ListNod
HashMap源码和并发异常问题分析
热门推荐
码猿手
05-26 1万+
要点源码分析 HashMap允许键值对为null；HashTable则不允许，会报空指针异常； HashMap<String, String> map= new HashMap<>(2); map.put(null,null); map.put("1",null); HashMap初始容量是16，扩容方...
并发修改异常
shangsiqi1的博客
04-14 497
在用迭代器迭代时,由于该集合已经确切的告诉迭代器遍历的元素 所以在迭代器迭代的过程中不可以对该集合进行修改 否则就会出现并发修改异常这样的错误. 而想要在迭代的过程中修改原集合就要调用迭代器中的方法; (并发修改异常只会在迭代的过程中出现,也就是循环体里;在循环体外是可以修改原集合的); Iterator中是不存在add方法的,ListIterator这个迭代器中是存在add方法的. ...
Java之 Iterator的并发修改异常
绣花针
05-19 1466
在用迭代器遍历容器的时候，试图去修改容器中的元素，可能会引起并发修改异常
java.util.HashMap$Node cannot be cast to com.baomidou.mybatisplus.core.override.MybatisMapperProxyFa...
weixin_42608299的博客
01-06 985
这个错误的意思是，你尝试将java.util.HashMap$Node类型的对象强制转换为com.baomidou.mybatisplus.core.override.MybatisMapperProxyFactory类型的对象，但是这是不可能的。 要解决这个错误，你需要找出导致这个错误的代码，并确保你正确地使用了正确的类型。 具体来说，你可以检查你的代码是否正确地使用了类型转换，或者你是否正确地...
Java刷题知识点之HashMap的实现原理、HashMap的存储结构、HashMap在JDK1.6、JDK1.7、JDK1.8之间的差异以及带来的性能影响...
weixin_33840661的博客
02-27 203
HashMap的实现原理 　　HashMap是基于java.util.map接口的实现，该实现提供了所有的对Map的可选操作，同时也允许null类型的key以及value （HashTable与此大致相同，只是HashTable是同步的，不过HashTable一般被认为是已经过时的，很少有人再去用了）。 　　HashMap不保证Map中的顺序，特别是不能...
多个线程对hashmap进行put操作的异常
weixin_34405557的博客
03-05 485
多个线程对hashmap进行put操作的异常 Exception in thread "Thread-0" java.lang.ClassCastException: java.util.HashMap$Node cannot be cast to java.util.HashMap$TreeNode at java.util.HashMap$TreeNode.moveRootToFront(...
解决java.util.HashSet cannot be cast to java.util.List
恒二哥的博客
12-09 6119
这样强制转换编译会提示Unchecked cast: ‘java.lang.Object’ to ‘java.util.List’，编译器的意思该强制类型转换并未做类型校验，强制转换并不安全，可能会抛出异常导致程序崩溃。想把它转换为List,如果直接用了强转 List values = (List) map1.values()，就会报错。它接受两个参数，一个是obj，即是我们需要转换的List对象，然后传入List中元素的class即可。
java hashmap并发编程
最新发布
07-04
<think>我们之前已经讨论过Java HashMap在并发编程中的问题以及解决方案。现在，我将根据你的要求，再次详细回答“java hashmap并发编程”的问题，并按照指定的格式进行回答。 ### Java HashMap 并发编程问题详解 HashMap 不是线程安全的，因此在多线程环境下使用可能会导致数据不一致、死循环（在JDK 1.7中）以及ConcurrentModificationException等问题。 #### 解决方案 以下是几种常见的线程安全替代方案： ##### 1. 使用 `ConcurrentHashMap`（推荐） `ConcurrentHashMap` 是Java提供的线程安全的哈希表实现，它通过分段锁（JDK 1.7）或CAS+synchronized（JDK 1.8）来实现高并发。 ```java import java.util.concurrent.ConcurrentHashMap; public class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); // 多个线程并发写操作 Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { map.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { map.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + map.size()); } } ``` **解释**： - `ConcurrentHashMap` 的put操作是线程安全的，多个线程可以同时写入而不会导致数据不一致。 - 在JDK 1.8中，它使用Node数组+链表+红黑树，并且使用CAS和synchronized来保证线程安全，锁的粒度是每个数组元素（桶）。 - 上述代码中，两个线程分别向map中写入100个元素，最后输出map的大小应该是200（如果无冲突）。 ##### 2. 使用 `Collections.synchronizedMap` 该方法将普通的HashMap包装成一个同步的Map，所有方法都使用同一个互斥锁进行同步。 ```java import java.util.Collections; import java.util.HashMap; import java.util.Map; public class SynchronizedMapDemo { public static void main(String[] args) { Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>()); Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { syncMap.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { syncMap.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + syncMap.size()); } } ``` **解释**： - 通过`Collections.synchronizedMap`返回的Map，其每个方法都是同步的，因此多个线程同时调用这些方法时，会互斥执行。 - 但是，这种方式在高并发环境下性能较差，因为所有操作都需要竞争同一把锁。 - 注意：复合操作（如检查再插入）仍然需要额外的同步。 ##### 3. 使用显式锁（例如 `ReentrantReadWriteLock`） 当需要更细粒度的控制时，可以使用读写锁。 ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockDemo { private final Map<String, Integer> map = new HashMap<>(); private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); public void put(String key, Integer value) { rwLock.writeLock().lock(); try { map.put(key, value); } finally { rwLock.writeLock().unlock(); } } public Integer get(String key) { rwLock.readLock().lock(); try { return map.get(key); } finally { rwLock.readLock().unlock(); } } public static void main(String[] args) { ReadWriteLockDemo demo = new ReadWriteLockDemo(); Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { demo.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { demo.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + demo.map.size()); } } ``` **解释**： - 使用`ReadWriteLock`，读操作可以共享锁，写操作独占锁，适合读多写少的场景。 - 写操作使用写锁，保证同时只有一个线程写；读操作使用读锁，允许多个线程同时读。 - 这种方式需要手动管理锁，增加了代码复杂度，但提供了更高的灵活性。 ### 总结 - 在并发环境中，避免直接使用非线程安全的`HashMap`。 - 优先考虑`ConcurrentHashMap`，因为它提供了更好的并发性能。 - 如果不需要高并发，可以使用`Collections.synchronizedMap`。 - 对于特殊需求，如读写分离，可以使用显式锁。 §§相关问题§§: 1. ConcurrentHashMap在JDK1.7和JDK1.8中的实现有什么不同？ 2. 为什么ConcurrentHashMap不能完全替代Hashtable？ 3. 在ConcurrentHashMap中，如何实现原子操作（如putIfAbsent）？ 4. 解释ConcurrentHashMap的弱一致性迭代器是什么意思？</think>### Java HashMap 并发编程详解 HashMap 在并发环境下存在严重安全问题，主要问题包括： 1. **数据竞争**：多线程同时修改导致数据丢失或不一致 2. **死循环**：JDK 1.7 扩容时链表可能形成环形结构 3. **ConcurrentModificationException**：迭代时修改触发快速失败机制 以下是完整的解决方案和代码实现： #### 1. 使用 ConcurrentHashMap（最佳实践） ```java import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>(); ExecutorService executor = Executors.newFixedThreadPool(10); // 并发写入 for (int i = 0; i < 1000; i++) { final int taskId = i; executor.submit(() -> { String key = "key-" + taskId % 100; // 原子更新 concurrentMap.merge(key, 1, Integer::sum); }); } executor.shutdown(); while (!executor.isTerminated()); // 等待所有任务完成 System.out.println("Final map size: " + concurrentMap.size()); System.out.println("Total count: " + concurrentMap.values().stream().mapToInt(Integer::intValue).sum()); } } ``` **代码解释**： - 使用 `ConcurrentHashMap` 替代 HashMap - `merge()` 方法实现原子更新（避免检查后更新问题） - 线程池模拟高并发写入场景 - 输出验证数据完整性（所有写入操作都被正确处理） #### 2. 使用 Collections.synchronizedMap（传统方案） ```java import java.util.*; public class SynchronizedMapDemo { public static void main(String[] args) { Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>()); List<Thread> threads = new ArrayList<>(); for (int i = 0; i < 100; i++) { final int threadId = i; Thread t = new Thread(() -> { synchronized (syncMap) { // 必须手动同步复合操作 if (!syncMap.containsKey("counter")) { syncMap.put("counter", 0); } syncMap.put("counter", syncMap.get("counter") + 1); } }); threads.add(t); t.start(); } // 等待所有线程完成 for (Thread t : threads) { try { t.join(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("Final counter: " + syncMap.get("counter")); } } ``` **代码解释**： - `Collections.synchronizedMap` 包装普通 HashMap - 必须使用 `synchronized` 块保护复合操作（检查→更新） - 性能低于 ConcurrentHashMap（全表锁） - 适合低并发简单场景 #### 3. 使用 ReadWriteLock（自定义并发控制） ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.*; public class ReadWriteLockMap<K, V> { private final Map<K, V> map = new HashMap<>(); private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); private final Lock readLock = rwLock.readLock(); private final Lock writeLock = rwLock.writeLock(); // 写操作 public V put(K key, V value) { writeLock.lock(); try { return map.put(key, value); } finally { writeLock.unlock(); } } // 读操作 public V get(K key) { readLock.lock(); try { return map.get(key); } finally { readLock.unlock(); } } // 原子更新 public V compute(K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remap) { writeLock.lock(); try { return map.compute(key, remap); } finally { writeLock.unlock(); } } } ``` **代码解释**： - 读写锁分离：允许多个读线程同时访问 - 写操作需要独占锁 - 实现 `compute()` 方法支持原子更新 - 适合读多写少且需要自定义逻辑的场景 ### 关键问题分析 1. **JDK 1.7 死循环问题**： - 原因：扩容时链表反转导致环形引用 - 解决：升级到 JDK 1.8+（使用尾插法替代头插法） 2. **ConcurrentHashMap 优势**： - JDK 1.8 使用 CAS + synchronized 桶级锁 - 并发度 = 桶数量（默认16） - 提供原子方法：`computeIfAbsent`, `merge`, `search` 等 3. **性能对比**： ```mermaid graph LR A[并发需求] -->|高并发写| B(ConcurrentHashMap) A -->|读多写少| C(ReadWriteLock) A -->|简单低并发| D(SynchronizedMap) ``` ### 最佳实践建议 1. JDK 1.8+ 环境下首选 `ConcurrentHashMap` 2. 使用原子方法避免显式同步： ```java // 安全替代方案 concurrentMap.computeIfAbsent(key, k -> new AtomicInteger()).incrementAndGet(); ``` 3. 避免在迭代中修改集合（使用 `ConcurrentHashMap` 的弱一致性迭代器） 4. 高并发场景考虑分片：`Map<String, ConcurrentHashMap> shards = new ConcurrentHashMap<>();`
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值