Andy.Zhou
随笔- 216 文章- 1 评论- 21
HashMap多线程并发问题分析
目录
并发问题的症状
HashMap数据结构
HashMap的rehash源代码
正常的ReHash过程
并发的Rehash过程
三种解决方案
转载: HashMap多线程并发问题分析
并发问题的症状
多线程put后可能导致get死循环
从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题。后来,我们的程序性能有问题,所以需要变成多线程的,于是,变成多线程后到了线上,发现程序经常占了100%的CPU,查看堆栈,你会发现程序都Hang在了HashMap.get()这个方法上了,重启程序后问题消失。但是过段时间又会来。而且,这个问题在测试环境里可能很难重现。
我们简单的看一下我们自己的代码,我们就知道HashMap被多个线程操作。而Java的文档说HashMap是非线程安全的,应该用ConcurrentHashMap。但是在这里我们可以来研究一下原因。简单代码如下:
package com.king.hashmap;
import java.util.HashMap;
public class TestLock {
private HashMap map = new HashMap();
public TestLock() {
Thread t1 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.put(new Integer(i), i);
}
System.out.println("t1 over");
}
};
Thread t2 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.put(new Integer(i), i);
}
System.out.println("t2 over");
}
};
Thread t3 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.put(new Integer(i), i);
}
System.out.println("t3 over");
}
};
Thread t4 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.put(new Integer(i), i);
}
System.out.println("t4 over");
}
};
Thread t5 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.put(new Integer(i), i);
}
System.out.println("t5 over");
}
};
Thread t6 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.get(new Integer(i));
}
System.out.println("t6 over");
}
};
Thread t7 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.get(new Integer(i));
}
System.out.println("t7 over");
}
};
Thread t8 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.get(new Integer(i));
}
System.out.println("t8 over");
}
};
Thread t9 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.get(new Integer(i));
}
System.out.println("t9 over");
}
};
Thread t10 = new Thread() {
public void run() {
for (int i = 0; i < 50000; i++) {
map.get(new Integer(i));
}
System.out.println("t10 over");
}
};
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
t7.start();
t8.start();
t9.start();
t10.start();
}
public static void main(String[] args) {
new TestLock();
}
}
就是启了10个线程,不断的往一个非线程安全的HashMap中put内容/get内容,put的内容很简单,key和value都是从0自增的整数(这个put的内容做的并不好,以致于后来干扰了我分析问题的思路)。对HashMap做并发写操作,我原以为只不过会产生脏数据的情况,但反复运行这个程序,会出现线程t1、t2被hang住的情况,多数情况下是一个线程被hang住另一个成功结束,偶尔会10个线程都被hang住。
产生这个死循环的根源在于对一个未保护的共享变量 — 一个"HashMap"数据结构的操作。当在所有操作的方法上加了"synchronized"后,一切恢复了正常。这算jvm的bug吗?应该说不是的,这个现象很早以前就报告出来了。Sun的工程师并不认为这是bug,而是建议在这样的场景下应采用"ConcurrentHashMap”,
CPU利用率过高一般是因为出现了出现了死循环,导致部分线程一直运行,占用cpu时间。问题原因就是HashMap是非线程安全的,多个线程put的时候造成了某个key值Entry key List的死循环,问题就这么产生了。
当另外一个线程get 这个Entry List 死循环的key的时候,这个get也会一直执行。最后结果是越来越多的线程死循环,最后导致服务器dang掉。我们一般认为HashMap重复插入某个值的时候,会覆盖之前的值,这个没错。但是对于多线程访问的时候,由于其内部实现机制(在多线程环境且未作同步的情况下,对同一个HashMap做put操作可能导致两个或以上线程同时做rehash动作,就可能导致循环键表出现,一旦出现线程将无法终止,持续占用CPU,导致CPU使用率居高不下),就可能出现安全问题了。
使用jstack工具dump出问题的那台服务器的栈信息。死循环的话,首先查找RUNNABLE的线程,找到问题代码如下:
java.lang.Thread.State:RUNNABLE
at java.util.HashMap.get(HashMap.java:303)
at com.sohu.twap.service.logic.TransformTweeter.doTransformTweetT5(TransformTweeter.java:183)
共出现了23次。
java.lang.Thread.State:RUNNABLE
at java.util.HashMap.put(HashMap.java:374)
at com.sohu.twap.service.logic.TransformTweeter.transformT5(TransformTweeter.java:816)
共出现了3次。
注意:不合理使用HashMap导致出现的是死循环而不是死锁。
多线程put的时候可能导致元素丢失
主要问题出在addEntry方法的new Entry (hash, key, value, e),如果两个线程都同时取得了e,则他们下一个元素都是e,然后赋值给table元素的时候有一个成功有一个丢失。
put非null元素后get出来的却是null
在transfer方法中代码如下:
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry e = src[j];
if (e != null) {
src[j] = null;
do {
Entry next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
在这个方法里,将旧数组赋值给src,遍历src,当src的元素非null时,就将src中的该元素置null,即将旧数组中的元素置null了,也就是这一句:
if (e != null) {
src[j] = null;
HashMap数据结构
我需要简单地说一下HashMap这个经典的数据结构。
HashMap通常会用一个指针数组(假设为table[])来做分散所有的key,当一个key被加入时,会通过Hash算法通过key算出这个数组的下标i,然后就把这个 插到table[i]中,如果有两个不同的key被算在了同一个i,那么就叫冲突,又叫碰撞,这样会在table[i]上形成一个链表。
我们知道,如果table[]的尺寸很小,比如只有2个,如果要放进10个keys的话,那么碰撞非常频繁,于是一个O(1)的查找算法,就变成了链表遍历,性能变成了O(n),这是Hash表的缺陷。
所以,Hash表的尺寸和容量非常的重要。一般来说,Hash表这个容器当有数据要插入时,都会检查容量有没有超过设定的thredhold,如果超过,需要增大Hash表的尺寸,但是这样一来,整个Hash表里的元素都需要被重算一遍。这叫rehash,这个成本相当的大。
HashMap的rehash源代码
下面,我们来看一下Java的HashMap的源代码。Put一个Key,Value对到Hash表中:
public V put(K key, V value)
{
......
//算Hash值
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
//如果该key已被插入,则替换掉旧的value (链接操作)
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++;
//该key不存在,需要增加一个结点
addEntry(hash, key, value, i);
return null;
}
检查容量是否超标:
void addEntry(int hash, K key, V value, int bucketIndex)
{
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
//查看当前的size是否超过了我们设定的阈值threshold,如果超过,需要resize
if (size++ >= threshold)
resize(2 * table.length);
}
新建一个更大尺寸的hash表,然后把数据从老的Hash表中迁移到新的Hash表中。
void resize(int newCapacity)
{
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
......
//创建一个新的Hash Table
Entry[] newTable = new Entry[newCapacity];
//将Old Hash Table上的数据迁移到New Hash Table上
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
迁移的源代码,注意高亮处:
void transfer(Entry[] newTable)
{
Entry[] src = table;
int newCapacity = newTable.length;
//下面这段代码的意思是:
// 从OldTable里摘一个元素出来,然后放到NewTable中
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);
}
}
}
好了,这个代码算是比较正常的。而且没有什么问题。
正常的ReHash过程
画了个图做了个演示。
- 我假设了我们的hash算法就是简单的用key mod 一下表的大小(也就是数组的长度)。
- 最上面的是old hash 表,其中的Hash表的size=2, 所以key = 3, 7, 5,在mod 2以后都冲突在table1这里了。
- 接下来的三个步骤是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。
三种解决方案
Hashtable替换HashMap
Hashtable 是同步的,但由迭代器返回的 Iterator 和由所有 Hashtable 的“collection 视图方法”返回的 Collection 的 listIterator 方法都是快速失败的:在创建 Iterator 之后,如果从结构上对 Hashtable 进行修改,除非通过 Iterator 自身的移除或添加方法,否则在任何时间以任何方式对其进行修改,Iterator 都将抛出 ConcurrentModificationException。因此,面对并发的修改,Iterator 很快就会完全失败,而不冒在将来某个不确定的时间发生任意不确定行为的风险。由 Hashtable 的键和值方法返回的 Enumeration 不是快速失败的。
注意,迭代器的快速失败行为无法得到保证,因为一般来说,不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此,为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误做法:迭代器的快速失败行为应该仅用于检测程序错误。
Collections.synchronizedMap将HashMap包装起来
返回由指定映射支持的同步(线程安全的)映射。为了保证按顺序访问,必须通过返回的映射完成对底层映射的所有访问。在返回的映射或其任意 collection 视图上进行迭代时,强制用户手工在返回的映射上进行同步:
Map m = Collections.synchronizedMap(new HashMap());
...
Set s = m.keySet(); // Needn't be in synchronized block
...
synchronized(m) { // Synchronizing on m, not s!
Iterator i = s.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
不遵从此建议将导致无法确定的行为。如果指定映射是可序列化的,则返回的映射也将是可序列化的。
ConcurrentHashMap替换HashMap
支持检索的完全并发和更新的所期望可调整并发的哈希表。此类遵守与 Hashtable 相同的功能规范,并且包括对应于 Hashtable 的每个方法的方法版本。不过,尽管所有操作都是线程安全的,但检索操作不必锁定,并且不支持以某种防止所有访问的方式锁定整个表。此类可以通过程序完全与 Hashtable 进行互操作,这取决于其线程安全,而与其同步细节无关。
检索操作(包括 get)通常不会受阻塞,因此,可能与更新操作交迭(包括 put 和 remove)。检索会影响最近完成的更新操作的结果。对于一些聚合操作,比如 putAll 和 clear,并发检索可能只影响某些条目的插入和移除。类似地,在创建迭代器/枚举时或自此之后,Iterators 和 Enumerations 返回在某一时间点上影响哈希表状态的元素。它们不会抛出 ConcurrentModificationException。不过,迭代器被设计成每次仅由一个线程使用。
分类: Collection
+加关注
4
0
« 上一篇:阿里巴巴、美团等各大互联网公司的 Java类 校招对本科生有什么要求?
» 下一篇:理解HTTP幂等性
posted @ 2016-04-18 01:01 Andrew.Zhou 阅读(21865) 评论(1) 编辑 收藏
发表评论
大佬,你的图是用什么画的。很漂亮
支持(0)反对(0)
注册用户登录后才能发表评论,请 登录 或 注册,访问网站首页。
【推荐】超50万VC++源码: 大型组态工控、电力仿真CAD与GIS源码库!
【前端】SpreadJS表格控件,可嵌入应用开发的在线Excel
【推荐】如何快速搭建人工智能应用?
【活动】AI技术全面场景化落地实践
【大赛】2018首届“顶天立地”AI开发者大赛
最新IT新闻:
· 苹果与权威IT认证机构推出Swift资格认证
· 大疆花2.8亿举办机器人版「王者荣耀」,想要传播工程师文化
· Google Calendar新功能:更好协调会议成员时间
· 童话大王郑渊洁举报拼多多 有3.4亿用户的假货天地?
· 腾讯网易巨头垄断下寻找出路 国产手游进军韩国
» 更多新闻...
最新知识库文章:
· 历史转折中的“杭派工程师”
· 如何提高代码质量?
· 在腾讯的八年,我的职业思考
· 为什么我离开了管理岗位
· 那些让人睡不着觉的bug,你有没有遭遇过?
昵称:Andrew.Zhou
园龄:2年10个月
粉丝:91
关注:5
+加关注
| |||||||||
日 | 一 | 二 | 三 | 四 | 五 | 六 | |||
---|---|---|---|---|---|---|---|---|---|
24 | 25 | 26 | 27 | 28 | 29 | 30 | |||
1 | 2 | 3 | 4 | 5 | 6 | 7 | |||
8 | 9 | 10 | 11 | 12 | 13 | 14 | |||
15 | 16 | 17 | 18 | 19 | 20 | 21 | |||
22 | 23 | 24 | 25 | 26 | 27 | 28 | |||
29 | 30 | 31 | 1 | 2 | 3 | 4 |
搜索
常用链接
随笔分类
- Algorithm(6)
- Collection(4)
- Concurrent(19)
- DB & SQL(4)
- Design(1)
- Framework(1)
- Front-End(2)
- Git(4)
- Hash & Cached(1)
- HTTP & HTTPS(5)
- Interview(16)
- iOS(11)
- iOS-Study(1)
- Java(16)
- Java Exception(3)
- Java I/O(2)
- Java NIO(2)
- JSP & Servlet(2)
- JVM(13)
- Linux(3)
- Markdown(3)
- Patterns(4)
- Python(1)
- Redis(1)
- Text(16)
- Tomcat(2)
- 剑指算法题(69)
随笔档案
- 2017年4月 (1)
- 2017年3月 (72)
- 2017年2月 (2)
- 2017年1月 (1)
- 2016年9月 (1)
- 2016年5月 (2)
- 2016年4月 (21)
- 2016年3月 (113)
- 2015年11月 (3)
相册
- 133个Java面试问题列表(4)
- Ajax原理学习(1)
- Andy React Study(1)
- Git 分支管理是一门艺术(5)
- Git使用教程(73)
- HashMap多线程并发问题分析(5)
- Interview(1)
- iOS 面试基础题目(1)
- iOS应用架构谈 view层的组织和调用方案(3)
- iOS应用架构谈 组件化方案(1)
- Java ConcurrentModificationException异常原因和解决方法(2)
- Java I/O学习(9)
- Java NIO:NIO概述(2)
- Java NIO:浅析I/O模型(2)
- Java 字节流与字符流的区别(4)
- Java:类与继承(2)
- Javaweb异常提示信息统一处理(6)
- Java并发编程:Lock(2)
- Java并发编程:synchronized(4)
- Java并发编程:Thread类的使用(7)
- Java并发编程:volatile关键字解析(2)
- Java并发编程:并发容器之ConcurrentHashMap(3)
- Java并发编程:如何创建线程(1)
- Java并发编程:深入剖析ThreadLocal(8)
- Java并发编程:同步容器(3)
- Java并发编程:性能、扩展性和响应(1)
- Java常用排序算法/程序员必须掌握的8大排序算法(11)
- Java基础之泛型(2)
- Java基础之集合(4)
- Java集合框架:HashMap(3)
- Java经典设计模式(4)
- Java垃圾回收机制(4)
- Java内部类详解(5)
- Java内存管理(2)
- Java输入输出流(17)
- Java位操作全面总结(1)
- Java线程面试题 Top 50(1)
- Java虚拟机类加载机制(1)
- Java异常处理和设计(4)
- Java异常封装(2)
- Java中synchronized的使用实例(2)
- Java中的static关键字解析(2)
- JVM的内存区域划分(3)
- JVM调优总结(21)
- MySQL 死锁问题分析(13)
- MySQL通用优化手册(42)
- Objective-C与JavaScript交互的那些事(2)
- Redis时延问题分析及应对(3)
- Servlet再度学习(2)
- Spring中@Transactional事务回滚(2)
- SQL实例整理(7)
- Tomcat APR & Linux Optimization(10)
- Trace VM(2)
- Tuning Optimization(7)
- Xcode + Swift 制作动态原型(18)
- 阿里Linux Shell脚本面试25个经典问答(13)
- 初探Java字符串(7)
- 递归回溯groupSum(1)
- 对一致性Hash算法,Java代码实现的深入研究(2)
- 画图解释 SQL Join 语句(6)
- 简明 Git 命令速查表(1)
- 剑指Offer(2)
- 理解Cookie和Session机制(5)
- 理解HTTP幂等性(2)
- 理解Java虚拟机体系结构(8)
- 秒杀系统架构分析与实战(25)
- 浅谈Java中的equals和==(2)
- 浅谈Java中的深拷贝和浅拷贝(1)
- 浅析Java中的final关键字(3)
- 浅析Java中的访问权限控制(4)
- 三张图彻底了解Java中字符串的不变性(3)
- 深入剖析Java中的装箱和拆箱(1)
- 什么是堆和栈,它们在哪儿?(4)
- 使用XIB实现一个简单view(3)
- 详解https是如何确保安全的?(2)
- 在Xcode中使用Git进行源码版本控制(40)
最新评论
- 1. Re:理解Cookie和Session机制
- 谢谢大佬,一文讲解透了这个概念
- --沉默哥
- 2. Re:秒杀系统架构分析与实战
- 牛逼啊
能把这种经验总结分享出来足见楼主水准够高! - --蓝黑色的心
- 3. Re:理解Cookie和Session机制
- mark 谢谢大佬
- --阿木single
- 4. Re:理解Cookie和Session机制
- mark
- --smallwangtoumusk
- 5. Re:理解Cookie和Session机制
- 谢谢谢谢!
- --LindaLovelace
阅读排行榜
- 1. Java ConcurrentModificationException异常原因和解决方法(97892)
- 2. 理解Cookie和Session机制(72005)
- 3. Javaweb异常提示信息统一处理(26365)
- 4. HashMap多线程并发问题分析(21865)
- 5. 你真的会写单例模式吗-------Java实现(19892)
评论排行榜
- 1. 理解Cookie和Session机制(12)
- 2. Java ConcurrentModificationException异常原因和解决方法(2)
- 3. 秒杀系统架构分析与实战(2)
- 4. Java中synchronized的使用实例(1)
- 5. Java内存管理(1)
推荐排行榜
- 1. 理解Cookie和Session机制(18)
- 2. Java ConcurrentModificationException异常原因和解决方法(10)
- 3. 秒杀系统架构分析与实战(8)
- 4. HashMap多线程并发问题分析(4)
- 5. Java内存管理(2)
Copyright ©2018 Andrew.Zhou