jdk1.7版hashmap在多线程环境下的死循环问题_hashmap在1.7情况下的多线程死循环问题-CSDN博客

一、背景介绍：

在看JDK1.7的HashMap源码是看到了resize()的源代码，当时发现在将old链表中引用数据复制到新的链表中时，新table[]的列表采用LIFO方式，即队头插入。这样做的目的是：避免尾部遍历。（尾部遍历是指新列表插入数据时，每次遍历旧列表队尾的位置）因为，直接插入的效率更高。
然而直接采用队头插入，会使得新链表数据倒序

二、存在的问题：

采用队头插入的方式，导致了HashMap在“多线程环境下”的死循环问题

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

我们简单的看一下我们自己的代码，我们就知道HashMap被多个线程操作。而Java的文档说HashMap是非线程安全的，应该用ConcurrentHashMap。

但是在这里我们可以来研究一下原因。

Hash表数据结构
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表的尺寸和容量非常的重要。一般来说，Hash表这个容器当有数据要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大Hash表的尺寸，但是这样一来，整个Hash表里的无素都需要被重算一遍。这叫rehash，这个成本相当的大。

相信大家对这个基础知识已经很熟悉了。

HashMap的rehash源代码

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
　　　　　//for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去（数组不存储实际数据，所以仅仅是拷贝引用而已）和 arraylist 或者 linkedlist 中的clone方法是一样的 都是浅拷贝关系
        foreach (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);
　　　　　　　　　 //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
　　　　　　　　　 //第一次时 newTable[i] = null

                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

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

正常的ReHash的过程

画了个图做了个演示。

1，我假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。
2，最上面的是old hash 表，其中的Hash表的size=2, 所以key = 3, 7, 5，在mod 2以后都冲突在table[1]这里了。
3，接下来的三个步骤是Hash表 resize成4，然后所有的<key,value> 重新rehash的过程
在这里插入图片描述
并发下的Rehash过程
1）假设我们有两个线程。我用红色和浅蓝色标注了一下。

我们再回头看一下我们的 transfer代码中的这个细节：

   int i = indexFor(e.hash, newCapacity); **//假设线程一执行到这 失去了运行权限**
    //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
    //第一次时 newTable[i] = null
    
    e.next = newTable[i];
    newTable[i] = e;
    e = next;

而我们的线程二执行完成了。于是我们有下面的这个样子。
在这里插入图片描述
注意，因为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。

三、问题解决：

JDK1.8的优化
通过增加tail指针，既避免了死循环问题（让数据直接插入到队尾），又避免了尾部遍历。
个人感觉这个改进就好多了，在jdk1.8的 LinkedList 类中也是通过一个头和尾来实现设计，通过巧妙的算法（具体见《HashMap JDK1.8实现原理》扩容部分）既避免了出错，又提高了操作效率。
代码如下：

// 扩容兼初始化
	final Node<K, V>[] resize() {
		Node<K, V>[] oldTab = table;
		int oldCap = (oldTab == null) ? 0 : oldTab.length;// 数组长度
		int oldThr = threshold;// 临界值
		int newCap, newThr = 0;
		if (oldCap > 0) {
			// 扩容
			if (oldCap >= MAXIMUM_CAPACITY) {
				// 原数组长度大于最大容量(1073741824) 则将threshold设为Integer.MAX_VALUE=2147483647
				// 接近MAXIMUM_CAPACITY的两倍
				threshold = Integer.MAX_VALUE;
				return oldTab;
			} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
				// 新数组长度 是原来的2倍，
				// 临界值也扩大为原来2倍
				newThr = oldThr << 1;
			}
		} else if (oldThr > 0) {
			// 如果原来的thredshold大于0则将容量设为原来的thredshold
			// 在第一次带参数初始化时候会有这种情况
			newCap = oldThr;
		} else {
			// 在默认无参数初始化会有这种情况
			newCap = DEFAULT_INITIAL_CAPACITY;// 16
			newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);// 0.75*16=12
		}
		if (newThr == 0) {
			// 如果新 的容量 ==0
			float ft = (float) newCap * loadFactor;// loadFactor 哈希加载因子 默认0.75,可在初始化时传入,16*0.75=12 可以放12个键值对
			newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ? (int) ft : Integer.MAX_VALUE);
		}
		threshold = newThr;// 将临界值设置为新临界值
		@SuppressWarnings({ "rawtypes", "unchecked" })
		// 扩容
		Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
		table = newTab;
		// 如果原来的table有数据，则将数据复制到新的table中
		if (oldTab != null) {
			// 根据容量进行循环整个数组，将非空元素进行复制
			for (int j = 0; j < oldCap; ++j) {
				Node<K, V> e;
				// 获取数组的第j个元素
				if ((e = oldTab[j]) != null) {
					oldTab[j] = null;
					// 如果链表只有一个，则进行直接赋值
					if (e.next == null)
						// e.hash & (newCap - 1) 确定元素存放位置
						newTab[e.hash & (newCap - 1)] = e;
					else if (e instanceof TreeNode)
                    //如果原来这个节点已经转化为红黑树了，
                    //那么我们去将树上的节点rehash之后根据hash值放到新地方
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

					else {
						// 进行链表复制
						// 方法比较特殊： 它并没有重新计算元素在数组中的位置
						// 而是采用了 原始位置加原数组长度的方法计算得到位置
						Node<K, V> loHead = null, loTail = null;
						Node<K, V> hiHead = null, hiTail = null;
						Node<K, V> next;
						do {
							/*********************************************/
							/**
							 * 注: e本身就是一个链表的节点，它有 自身的值和next(链表的值)，但是因为next值对节点扩容没有帮助，
							 * 所有在下面讨论中，我近似认为 e是一个只有自身值，而没有next值的元素。
							 */
							/*********************************************/
							next = e.next;
							// 注意：不是(e.hash & (oldCap-1));而是(e.hash & oldCap)

							// (e.hash & oldCap) 得到的是 元素的在数组中的位置是否需要移动,示例如下
							// 示例1：
							// e.hash=10 0000 1010
							// oldCap=16 0001 0000
							//	 &   =0	 0000 0000       比较高位的第一位 0
							//结论：元素位置在扩容后数组中的位置没有发生改变
							
							// 示例2：
							// e.hash=17 0001 0001
							// oldCap=16 0001 0000
							//	 &   =1	 0001 0000      比较高位的第一位   1
							//结论：元素位置在扩容后数组中的位置发生了改变，新的下标位置是原下标位置+原数组长度
							
							// (e.hash & (oldCap-1)) 得到的是下标位置,示例如下
							//   e.hash=10 0000 1010
							// oldCap-1=15 0000 1111
							//      &  =10 0000 1010
								
							//   e.hash=17 0001 0001
							// oldCap-1=15 0000 1111
							//      &  =1  0000 0001
							
							//新下标位置
							//   e.hash=17 0001 0001
							// newCap-1=31 0001 1111    newCap=32
							//      &  =17 0001 0001    1+oldCap = 1+16
							
							//元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
							// 0000 0001->0001 0001

							if ((e.hash & oldCap) == 0) {
								// 如果原元素位置没有发生变化
								if (loTail == null)
									loHead = e;// 确定首元素
								// 第一次进入时	  e   -> aa  ; loHead-> aa
								else
									loTail.next = e;
								//第二次进入时		loTail-> aa  ;    e  -> bb ;  loTail.next -> bb;而loHead和loTail是指向同一块内存的，所以loHead.next 地址为 bb  
								//第三次进入时		loTail-> bb  ;    e  -> cc ;  loTail.next 地址为 cc;loHead.next.next = cc
								loTail = e;
								// 第一次进入时   	  e   -> aa  ; loTail-> aa loTail指向了和  loHead相同的内存空间
								// 第二次进入时               e   -> bb  ; loTail-> bb loTail指向了和  loTail.next（loHead.next）相同的内存空间   loTail=loTail.next
								// 第三次进入时               e   -> cc  ; loTail-> cc loTail指向了和  loTail.next(loHead.next.next)相同的内存
							} else {
								//与上面同理
								
								if (hiTail == null)
									hiHead = e;
								else
									hiTail.next = e;
								hiTail = e;
							}
						} while ((e = next) != null);//这一块就是 旧链表迁移新链表
						//总结：1.8中 旧链表迁移新链表    链表元素相对位置没有变化; 实际是对对象的内存地址进行操作 
						//在1.7中  旧链表迁移新链表        如果在新表的数组索引位置相同，则链表元素会倒置
						if (loTail != null) {
							loTail.next = null;// 将链表的尾节点 的next 设置为空
							newTab[j] = loHead;
						}
						if (hiTail != null) {
							hiTail.next = null;// 将链表的尾节点 的next 设置为空
							newTab[j + oldCap] = hiHead;
						}
					}
				}
			}
		}
		return newTab;
	}