HashMap在并发下引起的死循环

小鱼儿 2022-12-13 04:35 158阅读 0赞

## 问题的症状 ##

发现线上程序经常占了100%的CPU，查看堆栈，你会发现程序都hang在了HashMap.get()这个方法上了，重启程序后问题消失，但是过段时间又会来。而且，这个问题在测试环境里可能很难重现。

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

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

## HashMap的rehash源代码 ##

下面，我们来看一下jdk 7的HashMap的源代码。

Put一个Key,Value对到Hash表中：

public V put(K key, V value)
    { 
        ......
        //算Hash值
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        //如果该key已被插入，则替换掉旧的value （链接操作）
        for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //该key不存在，需要增加一个结点
        addEntry(hash, key, value, i);
        return null;
    }

检查容量是否超标

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

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

void resize(int newCapacity)
    { 
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        ......
        //创建一个新的Hash Table
        Entry[] newTable = new Entry[newCapacity];
        //将Old Hash Table上的数据迁移到New Hash Table上
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

迁移的源代码

void transfer(Entry[] newTable)
    { 
        Entry[] src = table;
        int newCapacity = newTable.length;
        //下面这段代码的意思是：
        // 从OldTable里摘一个元素出来，然后放到NewTable中
        for (int j = 0; j < src.length; j++) { 
            Entry<K,V> e = src[j];
            if (e != null) { 
                src[j] = null;
                do { 
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

## 正常的ReHash的过程 ##

画了个图做了个演示。

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

## 并发下的Rehash ##

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

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

而我们的线程二执行完成了。于是我们有下面的这个样子。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 1]  
注意，**因为Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。** 我们可以看到链表的顺序被反转后。

2）**线程一被调度回来执行。  
先是执行 newTalbe\[i\] = e;  
然后是e = next，导致了e指向了key(7)，  
而下一次循环的next = e.next导致了next指向了key(3)**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 2]  
**3）一切安好。**  
线程一接着工作。**把key(7)摘下来，放到newTable\[i\]的第一个，然后把e和next往下移。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 3]  
**4）环形链接出现。  
e.next = newTable\[i\] 导致 key(3).next 指向了 key(7)  
注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 4]  
**于是，当我们的线程一调用到，HashTable.get(11)时，悲剧就出现了——Infinite Loop。**

## JDK 8 的改进 ##

JDK 8 中采用的是位桶 + 链表/红黑树的方式，当某个位桶的链表的长度超过 8 的时候，这个链表就将转换成红黑树

HashMap 不会因为多线程 put 导致死循环（JDK 8 用 head 和 tail 来保证链表的顺序和之前一样；JDK 7 rehash 会倒置链表元素），但是还会有数据丢失等弊端（并发本身的问题）。因此多线程情况下还是建议使用 ConcurrentHashMap

## 为什么线程不安全 ##

HashMap 在并发时可能出现的问题主要是两方面：

*  如果多个线程同时使用 put 方法添加元素，而且假设正好存在两个 put 的 key 发生了碰撞（根据 hash 值计算的 bucket一样），那么根据 HashMap 的实现，这两个 key 会添加到数组的同一个位置，这样最终就会发生其中一个线程 put 的数据被覆盖
 *  如果多个线程同时检测到元素个数超过数组大小 \* loadFactor，这样就会发生多个线程同时对 Node数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程 put 的数据也丢失。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/a1aec487fd6841b794f6f0c5dcb8e739.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/c241e3907eb542a8bd15880137998421.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/e9528a2e1fd2471bb89e6ab9f2baa673.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/8d5f81e82a66417fb24d7df7150d55c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmd4aW5jc2Ru_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/a34a3cef773345c6a69d844a83d827c8.png