问题的症状
从前我们的Java代码因为一些原因使用了HashMap这个东西,但是当时的程序是单线程的,一切都没有问题。后来,我们的程序性能有问题,所以需要变成多线程的,于是,变成多线程后到了线上,发现程序经常占了100%的CPU,查看堆栈,你会发现程序都Hang在了HashMap.get()这个方法上了,重启程序后问题消失。但是过段时间又会来。而且,这个问题在测试环境里可能很难重现。
我们简单的看一下我们自己的代码,就知道HashMap被多个线程操作。而Java的文档说HashMap是非线程安全的,应该用ConcurrentHashMap。
但是在这里我们可以来研究一下原因。
Hash表的数据结构
我需要简单地说一下HashMap这个经典的数据结构。
HashMap通常会用一个指针数组(假设为table[])来做分散所有的key,当一个key被加入时,会通过Hash算法通过key算出这个数组的下标i,然后就把这个<key, value>插到table[i]中,如果有两个不同的key被算在了同一个i,那么就叫冲突,又叫碰撞,这样会在table[i]上形成一个链表。
我们知道,如果table[]的尺寸很小,比如只有2个,如果要放进10个keys的话,那么碰撞非常频繁,于是一个O(1)的查找算法,就变成了链表遍历,性能变成了O(n),这是Hash表的缺陷(可参看《Hash Collision DoS问题》)。
所以,Hash表的尺寸和容量非常的重要。一般来说,Hash表这个容器当有数据要插入时,都会检查容量有没有超过设定的threshold,如果超过,需要增大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 }
当我们往HashMap中put元素时,现根据key的hash值得到这个元素在数组中的位置(即下标),然后就可以把这个元素放到对应的位置中了。如果这个元素所在的位置上已经存放有其它元素了,那么在同一个位置上的元素将以链表的形式存放,新加入的放在链头,而先前加入的放在链尾。
检查容量是否超标
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的过程
画了个图做了个演示。
- 假设我们的hash算法就是简单的用key mod一下表的大小(也就是数组的长度)
- 最上面的是old hash表,其中的Hash表的size = 2,所以key = 3,7,5,在mod 2以后都冲突在table[1]这里了。
- 接下来的三个步骤是Hash表resize为4,然后所有的<key,value>重新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);
而我们的线程二执行完成了。(注意:这里的执行完成是指do...while循环执行 完毕,且HashMap中成员变量table已更新为线程二持有的newTable。注意!!!线程一和线程二进去transfer()后,newTable实际上是两个)于是我们有下面的这个样子。
注意,因为Thread1的e指向了key(3),而next指向了key(7),其在线程二rehash后,指向了线程二重组后的链表。我们可以看到链表的顺序被反转了。
2)线程一被调度回来执行
- 先是执行newTable[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),环形链表出现。
接着newTable[i] = e,即把key(3)摘下来,放到newTable[i]的第一个,然后把e和往下移(e = next),此时next为null,执行后e和next都指向null,进行while判断为false,跳出do...while循环。
可以看到,实际上3这个元素被transfer了2次。
而后HashMap中成员变量table即变为上面新生成的newTable(参看resize()函数中执行完transfer()函数的下一句:table = newTable)。
此后,若get()方法取key值时需要到table[3]下的链表中去查找时,比如get(11)时,就会出现Infinite Loop。附上HashMap的get()方法:
1 public V get(Object key) { 2 //如果key为null,则直接去table[0]处去检索即可。 3 if (key == null) 4 return getForNullKey(); 5 Entry<K,V> entry = getEntry(key); 6 return null == entry ? null : entry.getValue(); 7 } 8 9 final Entry<K,V> getEntry(Object key) { 10 11 if (size == 0) { 12 return null; 13 } 14 //通过key的hashcode值计算hash值 15 int hash = (key == null) ? 0 : hash(key); 16 //indexFor (hash&length-1) 获取最终数组索引,然后遍历链表,通过equals方法比对找出对应记录 17 for (Entry<K,V> e = table[indexFor(hash, table.length)]; 18 e != null; 19 e = e.next) { 20 Object k; 21 if (e.hash == hash && 22 ((k = e.key) == key || (key != null && key.equals(k)))) 23 return e; 24 } 25 return null; 26 }
get(11)时,因为环形链表的缘故,e一直等不到null的情况,且key值为11在这段环形链表中(只有key值为3和7)又没有,所以也不会return,即程序会一直死循环在这里!
实际上,put的时候,当访问到那段环形链表时,也会造成死循环。
转载自《疫苗:JAVA HASHMAP的死循环》