转载: HashMap多线程并发问题分析

并发问题的症状

多线程put后可能导致get死循环

从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题。后来,我们的程序性能有问题,所以需要变成多线程的,于是,变成多线程后到了线上,发现程序经常占了100%的CPU,查看堆栈,你会发现程序都Hang在了HashMap.get()这个方法上了,重启程序后问题消失。但是过段时间又会来。而且,这个问题在测试环境里可能很难重现。

我们简单的看一下我们自己的代码,我们就知道HashMap被多个线程操作。而Java的文档说HashMap是非线程安全的,应该用ConcurrentHashMap。但是在这里我们可以来研究一下原因。简单代码如下:

  1. package com.king.hashmap;
  2. import java.util.HashMap;
  3. public class TestLock {
  4. private HashMap map = new HashMap();
  5. public TestLock() {
  6. Thread t1 = new Thread() {
  7. public void run() {
  8. for (int i = 0; i < 50000; i++) {
  9. map.put(new Integer(i), i);
  10. }
  11. System.out.println("t1 over");
  12. }
  13. };
  14. Thread t2 = new Thread() {
  15. public void run() {
  16. for (int i = 0; i < 50000; i++) {
  17. map.put(new Integer(i), i);
  18. }
  19. System.out.println("t2 over");
  20. }
  21. };
  22. Thread t3 = new Thread() {
  23. public void run() {
  24. for (int i = 0; i < 50000; i++) {
  25. map.put(new Integer(i), i);
  26. }
  27. System.out.println("t3 over");
  28. }
  29. };
  30. Thread t4 = new Thread() {
  31. public void run() {
  32. for (int i = 0; i < 50000; i++) {
  33. map.put(new Integer(i), i);
  34. }
  35. System.out.println("t4 over");
  36. }
  37. };
  38. Thread t5 = new Thread() {
  39. public void run() {
  40. for (int i = 0; i < 50000; i++) {
  41. map.put(new Integer(i), i);
  42. }
  43. System.out.println("t5 over");
  44. }
  45. };
  46. Thread t6 = new Thread() {
  47. public void run() {
  48. for (int i = 0; i < 50000; i++) {
  49. map.get(new Integer(i));
  50. }
  51. System.out.println("t6 over");
  52. }
  53. };
  54. Thread t7 = new Thread() {
  55. public void run() {
  56. for (int i = 0; i < 50000; i++) {
  57. map.get(new Integer(i));
  58. }
  59. System.out.println("t7 over");
  60. }
  61. };
  62. Thread t8 = new Thread() {
  63. public void run() {
  64. for (int i = 0; i < 50000; i++) {
  65. map.get(new Integer(i));
  66. }
  67. System.out.println("t8 over");
  68. }
  69. };
  70. Thread t9 = new Thread() {
  71. public void run() {
  72. for (int i = 0; i < 50000; i++) {
  73. map.get(new Integer(i));
  74. }
  75. System.out.println("t9 over");
  76. }
  77. };
  78. Thread t10 = new Thread() {
  79. public void run() {
  80. for (int i = 0; i < 50000; i++) {
  81. map.get(new Integer(i));
  82. }
  83. System.out.println("t10 over");
  84. }
  85. };
  86. t1.start();
  87. t2.start();
  88. t3.start();
  89. t4.start();
  90. t5.start();
  91. t6.start();
  92. t7.start();
  93. t8.start();
  94. t9.start();
  95. t10.start();
  96. }
  97. public static void main(String[] args) {
  98. new TestLock();
  99. }
  100. }

就是启了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方法中代码如下:

  1. void transfer(Entry[] newTable) {
  2. Entry[] src = table;
  3. int newCapacity = newTable.length;
  4. for (int j = 0; j < src.length; j++) {
  5. Entry e = src[j];
  6. if (e != null) {
  7. src[j] = null;
  8. do {
  9. Entry next = e.next;
  10. int i = indexFor(e.hash, newCapacity);
  11. e.next = newTable[i];
  12. newTable[i] = e;
  13. e = next;
  14. } while (e != null);
  15. }
  16. }
  17. }

在这个方法里,将旧数组赋值给src,遍历src,当src的元素非null时,就将src中的该元素置null,即将旧数组中的元素置null了,也就是这一句:

  1. if (e != null) {
  2. 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表中:

  1. public V put(K key, V value)
  2. {
  3. ......
  4. //算Hash值
  5. int hash = hash(key.hashCode());
  6. int i = indexFor(hash, table.length);
  7. //如果该key已被插入,则替换掉旧的value (链接操作)
  8. for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  9. Object k;
  10. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
  11. V oldValue = e.value;
  12. e.value = value;
  13. e.recordAccess(this);
  14. return oldValue;
  15. }
  16. }
  17. modCount++;
  18. //该key不存在,需要增加一个结点
  19. addEntry(hash, key, value, i);
  20. return null;
  21. }

检查容量是否超标:

  1. void addEntry(int hash, K key, V value, int bucketIndex)
  2. {
  3. Entry<K,V> e = table[bucketIndex];
  4. table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  5. //查看当前的size是否超过了我们设定的阈值threshold,如果超过,需要resize
  6. if (size++ >= threshold)
  7. resize(2 * table.length);
  8. }

新建一个更大尺寸的hash表,然后把数据从老的Hash表中迁移到新的Hash表中。

  1. void resize(int newCapacity)
  2. {
  3. Entry[] oldTable = table;
  4. int oldCapacity = oldTable.length;
  5. ......
  6. //创建一个新的Hash Table
  7. Entry[] newTable = new Entry[newCapacity];
  8. //将Old Hash Table上的数据迁移到New Hash Table上
  9. transfer(newTable);
  10. table = newTable;
  11. threshold = (int)(newCapacity * loadFactor);
  12. }

迁移的源代码,注意高亮处:

  1. void transfer(Entry[] newTable)
  2. {
  3. Entry[] src = table;
  4. int newCapacity = newTable.length;
  5. //下面这段代码的意思是:
  6. // 从OldTable里摘一个元素出来,然后放到NewTable中
  7. for (int j = 0; j < src.length; j++) {
  8. Entry<K,V> e = src[j];
  9. if (e != null) {
  10. src[j] = null;
  11. do {
  12. Entry<K,V> next = e.next;
  13. int i = indexFor(e.hash, newCapacity);
  14. e.next = newTable[i];
  15. newTable[i] = e;
  16. e = next;
  17. } while (e != null);
  18. }
  19. }
  20. }

好了,这个代码算是比较正常的。而且没有什么问题。

正常的ReHash过程

画了个图做了个演示。

  1. 我假设了我们的hash算法就是简单的用key mod 一下表的大小(也就是数组的长度)。
  2. 最上面的是old hash 表,其中的Hash表的size=2, 所以key = 3, 7, 5,在mod 2以后都冲突在table1这里了。
  3. 接下来的三个步骤是Hash表 resize成4,然后所有的 重新rehash的过程。

并发的Rehash过程

(1)假设我们有两个线程。我用红色和浅蓝色标注了一下。我们再回头看一下我们的 transfer代码中的这个细节:

  1. do {
  2. Entry<K,V> next = e.next; // <--假设线程一执行到这里就被调度挂起了
  3. int i = indexFor(e.hash, newCapacity);
  4. e.next = newTable[i];
  5. newTable[i] = e;
  6. e = next;
  7. } while (e != null);

而我们的线程二执行完成了。于是我们有下面的这个样子。

注意:因为Thread1的 e 指向了key(3),而next指向了key(7),其在线程二rehash后,指向了线程二重组后的链表。我们可以看到链表的顺序被反转后。

(2)线程一被调度回来执行。

  1. 先是执行 newTalbe[i] = e。
  2. 然后是e = next,导致了e指向了key(7)。
  3. 而下一次循环的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 视图上进行迭代时,强制用户手工在返回的映射上进行同步:

  1. Map m = Collections.synchronizedMap(new HashMap());
  2. ...
  3. Set s = m.keySet(); // Needn't be in synchronized block
  4. ...
  5. synchronized(m) { // Synchronizing on m, not s!
  6. Iterator i = s.iterator(); // Must be in synchronized block
  7. while (i.hasNext())
  8. foo(i.next());
  9. }

不遵从此建议将导致无法确定的行为。如果指定映射是可序列化的,则返回的映射也将是可序列化的。

ConcurrentHashMap替换HashMap

支持检索的完全并发和更新的所期望可调整并发的哈希表。此类遵守与 Hashtable 相同的功能规范,并且包括对应于 Hashtable 的每个方法的方法版本。不过,尽管所有操作都是线程安全的,但检索操作不必锁定,并且不支持以某种防止所有访问的方式锁定整个表。此类可以通过程序完全与 Hashtable 进行互操作,这取决于其线程安全,而与其同步细节无关。

检索操作(包括 get)通常不会受阻塞,因此,可能与更新操作交迭(包括 put 和 remove)。检索会影响最近完成的更新操作的结果。对于一些聚合操作,比如 putAll 和 clear,并发检索可能只影响某些条目的插入和移除。类似地,在创建迭代器/枚举时或自此之后,Iterators 和 Enumerations 返回在某一时间点上影响哈希表状态的元素。它们不会抛出 ConcurrentModificationException。不过,迭代器被设计成每次仅由一个线程使用。

HashMap多线程并发问题分析的更多相关文章

  1. HashMap多线程并发问题分析-正常和异常的rehash1(阿里)

    多线程put后可能导致get死循环 从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题.后来,我们的程序性能有问题,所以需要变成多线程的,于是,变 ...

  2. java--HashMap多线程并发问题分析

    并发问题的症状 多线程put后可能导致get死循环 从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题.后来,我们的程序性能有问题,所以需要变成多 ...

  3. Java 容器源码分析之HashMap多线程并发问题分析

    并发问题的症状 多线程put后可能导致get死循环 从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题.后来,我们的程序性能有问题,所以需要变成多 ...

  4. HashMap多线程并发的问题

    ---恢复内容开始--- 前言:大多数javaer都知道HashMap是线程不安全的,多线程环境下数据可能会发生错乱,一定要谨慎使用.这个结论是没错,可是HashMap的线程不安全远远不是数据脏读这么 ...

  5. Java - HashMap 多线程安全解析

    HashMap多线程并发问题分析 多线程put后可能导致get死循环 从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题.后来,我们的程序性能有问 ...

  6. Android-Java-单例模式优化&多线程并发

    上一篇博客,Android-Java单例模式,介绍了在真实开发过程中,普遍使用的几种单例模式,而今天这篇博客,将要对单利模式进行优化 并且 通过多线程并发来分析 单利模式的优化: 对于为什么会出现安全 ...

  7. Python 多线程并发程序设计与分析

    多线程并发程序设计与分析 by:授客 QQ:1033553122 1.技术难点分析与总结 难点1:线程运行时,运行顺序不固定 难点2:同一段代码,再不加锁的情况下,可能被多个线程同时执行,这会造成很多 ...

  8. Java面试题整理一(侧重多线程并发)

    1..是否可以在static环境中访问非static变量? 答:static变量在Java中是属于类的,它在所有的实例中的值是一样的.当类被Java虚拟机载入的时候,会对static变量进行初始化.如 ...

  9. 多线程并发 synchronized对象锁的控制与优化

    本文针对用户取款时多线程并发情境,进行相关多线程控制与优化的描述. 首先建立用户类UserTest.业务操作类SynchronizedTest.数据存取类DataStore,多线程测试类MultiTh ...

随机推荐

  1. Jquery remove 高级用法

    Jquery remove 高级用法 html 代码 <div class="file-image">abc1111</div><div class= ...

  2. [已解决] java 增加 ALPN支持

    添加javaVM参数: -Xbootclasspath/p:lib/alpn-boot-8.1.10.v20161026.jar 文章来源:http://www.cnblogs.com/gifisan ...

  3. Sql数据库时间的转换格式

    Select CONVERT(varchar(100), GETDATE(), 0): 05 16 2006 10:57AM   Select CONVERT(varchar(100), GETDAT ...

  4. php正则表达式 常用记录

    一正则汉字匹配数字id 汉字 $str = '<a href="http://music.baidu.com/song/121353608" target="_bl ...

  5. 自发行python版本制作(二)编译

    本系列文章第二篇主要说明windows环境的编译环境搭建以及编译过程. 编译环境选择: 1.选用作神一样存在的Microsoft Visual C++ Compiler for Python 2.7为 ...

  6. MyBatis传入参数为集合、数组SQL写法

    参考:http://blog.csdn.net/small____fish/article/details/8029030 foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合 ...

  7. MySQL为什么需要一个主键

    主键 表中每一行都应该有可以唯一标识自己的一列(或一组列). 一个顾客可以使用顾客编号列,而订单可以使用订单ID,雇员可以使用雇员ID 或 雇员社会保险号. 主键(primary key) 一列(或一 ...

  8. AngularJS使用指南

    ng-app 定义一个AngularJS应用程序 ng-model 把元素值绑定到AngularJS应用程序 ng-blind 把AngularJS应用程序数据绑定到HTML视图上 ng-init 初 ...

  9. MySql.Data.dll 不支持输出参数

    insert INTO stu(name) VALUES('maimai'); set @ReturnValue=@@IDENTITY; string sql="insert INTO st ...

  10. Android first--SharedPreferences

    public class MainActivity extends Activity { private EditText et_name;    private EditText et_pass; ...