日常学习中突然发现
HashMap
多线程情况下不安全的根本原因是什么导致的还不算很清晰?这就不能忍了,果断查找资料以及自己动手去操作操作。只有自己动手才能记得住!!题外话:今年的三四月份不同于以往了,现在每天最多接触的就是体温枪、健康码、口罩等。上班期间戴一天口罩感觉整个人都憋屈着,真希望疫情快快过去。
HashMap
是java
里面以Key-value
存储的一种集合对象,它使用的是数组加上链表的结构(1.8之后增加了红黑树),它允许key
和value
为null
,是一种无序并且线程不安全的集合对象,以下是他的结构图。
1.7
中会出现死循环和数据丢失。同时元素插入的方式是头插法。
void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; // 将oldTable中的每条链重新添加到 newTable 中 for (Entry<K,V> e : table) { while(null != e) { // 获取e的next节点 Entry<K,V> next = e.next; // 是否需要进行重hash if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } // 在新table中寻找数组位置 int i = indexFor(e.hash, newC apacity); // 将数组的值赋予当前e的next节点上 e.next = newTable[i]; // 当前值替换数组上元素 newTable[i] = e; //移动至下一节点 e = next; } } } 复制代码
上面的transfer
方法中可能发生多线程问题的地方有:
while
循环的时候,此时里面的元素都是逆向指向了,已经形成了一个死循环。与此同时如果该链表之后还有数据,则在线程B循环的时候就找不到剩余节点的值(1.8
内则利用了两对临时变量来保证在没有生成newTable
之前是不会改变之前的结构)。
1.8
版本的HashMap
是在1.7
上面进行给改造,虽然不会出现1.7
的情况,但是也是会出现新的问题,那就是有数据覆盖这样的问题。同时1.8
进行元素插入时使用的是尾插法。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) Node<K,V>[] tab; Node<K,V> p; int n, i; //判断table是否为空,如果是空的就创建一个table,并获取他的长度 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //如果计算出来的索引位置之前没有放过数据,就直接放入 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { //进入这里说明索引位置已经放入过数据了 Node<K,V> e; K k; //判断put的数据和之前的数据是否重复 //key的地址或key的equals()只要有一个相等就认为key重复了,就直接覆盖原来key的value if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //判断是否是红黑树,如果是红黑树就直接插入树中 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //如果不是红黑树,就遍历每个节点,判断链表长度是否大于8,如果大于就转换为红黑树 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } //判断索引每个元素的key是否与要插入的key相同,如果相同就直接覆盖 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //如果e不是null,说明没有迭代到最后就跳出了循环,说明链表中有相同的key,因此只需要将value覆盖,并将oldValue返回即可 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } //说明没有key相同,因此要插入一个key-value,并记录内部结构变化次数 fast-fail机制 ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } 复制代码
上面的put
方法中可能发生多线程问题的地方有:
if ((p = tab[i = (n - 1) & hash]) == null) ,这段代码是判断是否出现hash
碰撞,假设两个线程A、B都在进行put
操作,并且hash
函数计算出的插入下标相同的,当线程A执行完这段代码后由于时间片耗尽导致被挂起,而线程B得到时间片后在该下标处插入了元素,完成了正常的插入,然后线程A获得时间片,由于之前已经进行了hash
碰撞的判断,所有此时不会再进行判断,而是直接进行插入,这就导致了线程B插入的数据被线程A覆盖了,从而线程不安全。
++size,这段代码是用来操作当前集合的大小的。当线程A、B,这两个线程同时进行put操作时,假设当前集合的size
大小为10,当线程A执行到这行代码时,从主内存中获得size
的值为10后准备进行+1操作,但是由于时间片耗尽只好让出CPU,线程B快乐的拿到CPU
还是从主内存中拿到size
的值10进行+1操作,完成了put操作并将size=11写回主内存,然后线程A再次拿到CPU并继续执行(此时size的值仍为10),当执行完put操作后,还是将size=11写回内存,此时,线程A、B都执行了一次put操作,但是size的值只增加了1,由于数据覆盖又导致了线程不安全。
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; // 只有非第一次扩容才会进来(第一次扩容在第一次put) if (oldCap > 0) { // oldCap最大为MAXIMUM_CAPACITY(2^30)。 //如果oldCap也可以变成Integer.MAX_VALUE = (1<<31) - 1。那么每次hash&(cap-1)。可知道最低位无论hash是任何值时,都为0,也就是下标只有2^30种可能,有2^30-1个下标没有被使用。 //所以当容量为MAX_VALUE(2^31-1)时会造成一半的空间浪费,效率等同于MAXIMUM_CAPACITY(2^30) if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } // 带参初始化会进入这里,主要是为了重新算threshold else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; // 不带参初始化会进入这里 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 重新算threshold if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; // 扩容 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; // 复制数据到新table中 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; // 如果只有一个节点,则直接赋值 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; // 如果节点是树节点类型,则进行红黑树处理 else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // 之所以定义两个头两个尾对象,是由于链表中的元素的下标在扩容后,要么是原下标+oldCap,要么不变 Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; //遍历桶中的链表 do { next = e.next; // 下标没有改变 if ((e.hash & oldCap) == 0) { if (loTail == null) // 第一个节点 loHead = e; else // 加入到尾部 loTail.next = e; // 调整尾部元素 loTail = e; } // 下标改变 i //HashMap扩容的时候,不需要像Java1.7那样重新算hash值,只要看e.hash对应2*oldCap-1高位那个bit是1还是0就好了,是0下标没变,是1索引变成:原下标+oldCap else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); // 原下标对应的链表 if (loTail != null) { // 尾部节点next设置为null,代码严谨(因为上面的处理完毕之后,则最后一个节点的next指向的还是自己本身,则形成循环节点) loTail.next = null; newTab[j] = loHead; } // 新下标对应的链表 if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; } 复制代码
上面的resize
方法中可能发生多线程问题的地方有:
resize
,线程A先完成之后进行了数据的插入,此时线程B的resize
才刚刚返回,这种情况线程A进行的数据更新就会丢失。(线程A插入的数据刚好是线程B已经循环过的,那么此时线程Bresize
返回的节点中则不包含线程A的插入)HashMap的线程不安全主要体现在下面两个方面:
小伙伴们有其他的想法底下评论~,我会详细查看的。周末不出门,又可以省下一个口罩😃。
相关参考: JDK1.7和JDK1.8中HashMap为什么是线程不安全的?