探究HashMap线性不安全（二）——链表成环的详细过程

内容

​　　网上很多资料都详细地讲解了HashMap底层的实现，但是讲到HashMap的并发操作不是线性安全时，往往一笔带过：在多个线程并发扩容时，会在执行transfer()方法转移键值对时，造成链表成环，导致程序在执行get操作时形成死循环。

​　　对于没有研究过该过程的童鞋，很难费解这句话的含义。下面笔者分四个小节带着大家共同研究一下JDK1.7和JDK1.8版本下HashMap的线性不安全是怎么造成的，详细探究链表成环的形成过程。如果对于HashMap底层的put、get操作不清楚，建议先学习参考1中的内容。

适合人群

​　　Java进阶

说明

　　转载请说明出处：探究HashMap线性不安全（二）——链表成环的详细过程

 参考

​ 1、https://www.toutiao.com/i6544826418210013700/ HashMap底层数据结构原理

​ 2、https://www.toutiao.com/i6545790064104833539/ 为什么HashMap非线程安全

​ 3、https://blog.csdn.net/qq_32182461/article/details/81152025 hashmap并发情况下的成环原因（笔者认为该文是一种误解）

正文

​　　本节将详细探究HashMap扩容的键值对迁移过程，多线程并发执行transfer()方法是如何产生环形链表的。transfer()方法的代码为：

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //遍历table数组中键值对链
    for (Entry<K,V> e : table) {
        //遍历键值对e链上的所有键值对，当e指向null时结束
        while(null != e) {
            Entry<K,V> next = e.next;//断点一
            //通常rehash为false，不会重新计算键值对key的hash值
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            //根据扩容后的table数组长度计算键值对的index
            int i = indexFor(e.hash, newCapacity);
            //头插法，将后遍历的键值对存到链条的头部
            e.next = newTable[i];
            newTable[i] = e;
            //链条中的下一个键值对继续执行while循环。
            e = next;
        }
    }
}

 情景：

​　　两个线程A、B同时向HashMap中写入键值对，某个时刻HashMap已经到了Resize的临界点。由于多线程的执行没有必然的先后顺序，存在线程A未完成扩容，而线程B又进行扩容的情况，即两个线程都可能会执行扩容方法transfer()。此时两个线程都会遍历table数组中的键值对链，对于每个链执行while循环，迁移所有键值对。

　　假定HashMap中table数组的初始长度为4

​　　假如线程A和线程B都遍历到index为2的键值链（即Entry3->Entry2->null这条链）。由于CPU时间片分配的不确定性，线程B执行到代码中断点一的位置后暂停，此时线程B中的e指向Entry3，e.next指向Entry2。而线程A继续执行，完成了扩容操作。HashMap的数据结构为下图所示。

​　　重点！！：e和e.next为线程B中的引用变量，分别指向hashMap中的Entry3和Entry2。由于Entry3和Entry2是线程共享的，因此受线程A执行的影响，Entry3将指向null，Entry2指向Entry3。

​　　此时线程B中局部变量newTable的结构：

执行第一次循环：e为Entry3，e.next为Entry2（线程B暂停前e和e.next引用变量的指向）

//遍历e所在链上的所有键值对
while(null != e) {
    //断点1，此时线程B中的e为Entry3，e.next为Entry2
    Entry<K,V> next = e.next;
    //通常rehash为false，不会重新计算键值对key的hash值
    if (rehash) {
        e.hash = null == e.key ? 0 : hash(e.key);
    }
    //根据扩容后的table数组长度计算键值对的index
    int i = indexFor(e.hash, newCapacity);
    //头插法
    e.next = newTable[i];//将Entry3的next设置为null
    newTable[i] = e;//将Entry3放置到线程B newTable下标为3的位置
    //继续处理Entry2
    e = next;
}

 执行完第一次循环后线程B中局部变量newTable的结构：

执行完第一次循环后hashMap对象的结构：

执行第二次循环：e为Entry2，e.next为Entry3（受线程A影响，e和e.next引用变量的指向发生改变）

//遍历键值对e链上的所有键值对
while(null != e) {
    //断点1，e为Entry2，e.next为Entry3
    Entry<K,V> next = e.next;
    //通常rehash为false，不会重新计算键值对key的hash值
    if (rehash) {
        e.hash = null == e.key ? 0 : hash(e.key);
    }
    //由线程A的执行结果可知，Entry2的index也为3
    int i = indexFor(e.hash, newCapacity);
    //头插法，
    e.next = newTable[i];//将Entry2的next设置为Entry3
    newTable[i] = e; //newTable[3]设置为Entry2
    //另e等于Entry3，继续执行while循环。
    e = next;
}

执行完第二次循环后线程B中局部变量newTable的结构：

执行完第二次循环后hashMap对象的结构：

执行第三次循环：e变为Entry3，e.next为null

//遍历键值对e链上的所有键值对
while(null != e) {
    //断点1，此时线程B中的e变为Entry3，e.next为null
    Entry<K,V> next = e.next;
    //通常rehash为false，不会重新计算键值对key的hash值
    if (rehash) {
        e.hash = null == e.key ? 0 : hash(e.key);
    }
    //由线程A的执行结果可知，Entry3的index为3
    int i = indexFor(e.hash, newCapacity);
    //头插法
    e.next = newTable[i];//将Entry3的next设置为当前链条的首个键值对Entry2
    newTable[i] = e;//newTable[3]设置为Entry3
    //另e=next=null，结束while循环。
    e = next;
}

执行完第三次循环后线程B中局部变量newTable的结构：

执行完第三次循环后hashMap对象的结构：

​　　至此，线程B因为改变了Entry3的next属性，在hashMap对象中产生了环形链表。下一节，将探究环形链表是如何在hashMap查询时产生死循环的。