HashMap 原理及线程不安全详解

转载原文地址：HashMap原理及线程不安全详解 - 木子H的个人空间 - OSCHINA - 中文开源技术交流社区

一、HashMap

HashMap 是一个用于存储 Key-Value 键值对的集合，每一个键值对也叫做 Entry。这些个键值对（Entry）分散存储在一个数组当中，数组初始化长度为 16，数组中的每一个元素初始值都是 null，这个数组就是 HashMap 的主干。

1、put 方法原理

当调用 hashMap.put ("apple", 0) ，插入一个 Key 为 “apple" 的元素。这时候我们需要利用一个哈希函数来确定 Entry 的插入位置（index）：

index =  Hash（“apple”）

假定最后计算出的 index 是 2，那么结果如下：

但是，因为 HashMap 的长度是有限的，当插入的 Entry 越来越多时，再完美的 Hash 函数也难免会出现 index 冲突的情况。比如下面这样：

HashMap 数组的每一个元素不止是一个 Entry 对象，也是一个链表的头节点。每一个 Entry 对象通过 Next 指针指向它的下一个 Entry 节点。当新来的 Entry 映射到冲突的数组位置时，只需要插入到对应的链表即可：

需要注意的是，新来的 Entry 节点插入链表时，使用的是 “头插法”。 原因时 HashMap 的设计者认为后插入的元素被 get 的几率更大。

        2、get 方法原理

使用 Get 方法根据 Key 来查找 Value 的时候，发生了什么呢？

首先会把输入的 Key 做一次 Hash 映射，得到对应的 index：

index =  Hash（“apple”）

由于刚才所说的 Hash 冲突，同一个位置有可能匹配到多个 Entry，这时候就需要顺着对应链表的头节点，一个一个向下来查找。假设我们要查找的 Key 是 “apple”：

第一步，我们查看的是头节点 Entry6，Entry6 的 Key 是 banana，显然不是我们要找的结果。

第二步，我们查看的是 Next 节点 Entry1，Entry1 的 Key 是 apple，正是我们要找的结果。

之所以把 Entry6 放在头节点，是因为 HashMap 的发明者认为，后插入的 Entry 被查找的可能性更大。

3、HashMap 扩容（resize）

HashMap 的默认初始长度时 16，并且每次自动扩展或者手动初始化时，长度必须时 2 的幂。原因在于 HashMap 的数组下标算法，当 put 一个值时，会首先计算出 hash code，根据 hash code 决定放在数组的位置，考虑效率问题并没有采用取模的方式，而是采用按位与的方式

下面我们以 “book" 的 Key 来演示整个过程：

1. 计算 book 的 hashcode，结果为十进制的 3029737，二进制的 101110001110101110 1001。

2. 假定 HashMap 长度是默认的 16，计算 Length-1 的结果为十进制的 15，二进制的 1111。

3. 把以上两个结果做与运算，101110001110101110 1001 & 1111 = 1001，十进制是 9，所以 index=9。

可以说，Hash 算法最终得到的 index 结果，完全取决于 Key 的 Hashcode 值的最后几位。

在这种情况下，如果数字的长度不是 2 的幂，会发生以下结果：

假设 HashMap 的长度是 10，重复刚才的运算步骤：

单独看这个结果，表面上并没有问题。我们再来尝试一个新的 HashCode  101110001110101110 1011 ：

让我们再换一个 HashCode 101110001110101110 1111 试试  ：

虽然 HashCode 的倒数第二第三位从 0 变成了 1，但是运算的结果都是 1001。也就是说，当 HashMap 长度为 10 的时候，有些 index 结果的出现几率会更大，而有些 index 结果永远不会出现（比如 0111）！ 这样，显然不符合 Hash 算法均匀分布的原则。 反观长度 16 或者其他 2 的幂，Length-1 的值是所有二进制位全为 1，这种情况下，index 的结果等同于 HashCode 后几位的值。只要输入的 HashCode 本身分布均匀，Hash 算法的结果就是均匀的。

3、HashMap 的高并发问题

HashMap 是线程不安全的，原因就在于 HashMap 的 rehash。rehash 是 HashMap 扩容过程种的一个步骤。 HashMap 的容量是有限的。当经过多次元素插入，使得 HashMap 达到一定饱和度时，Key 映射位置发生冲突的几率会逐渐提高。 这时候，HashMap 需要扩展它的长度，也就是进行 Resize。 影响发生 Resize 的因素有两个：

1.Capacity

HashMap 的当前长度。上一期曾经说过，HashMap 的长度是 2 的幂。

2.LoadFactor

HashMap 负载因子，默认值为 0.75f。

衡量 HashMap 是否进行 Resize 的条件如下：

HashMap.Size   >=  Capacity * LoadFactor

HashMap 的扩容主要分为两步：

1. 扩容

创建一个新的 Entry 空数组，长度是原数组的 2 倍

2.ReHash

遍历原 Entry 数组，把所有的 Entry 重新 Hash 到新数组。为什么要重新 Hash 呢？因为长度扩大以后，Hash 的规则也随之改变。

让我们回顾一下 Hash 公式：

index =  HashCode（Key） &  （Length - 1）

当原数组长度为 8 时，Hash 运算是和 111B 做与运算；新数组长度为 16，Hash 运算是和 1111B 做与运算。Hash 结果显然不同。

ReHash 的 Java 代码如下：

/**
 * Transfers all entries from current table to newTable.
 */
void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (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);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

以上过程单线程下不会出现问题，但是当两个线程同时触发 resize 的时候就有可能出现问题

假设一个 HashMap 已经到了 Resize 的临界点。此时有两个线程 A 和 B，在同一时刻对 HashMap 进行 Put 操作：

此时达到 Resize 条件，两个线程各自进行 Rezie 的第一步，也就是扩容：

这时候，两个线程都走到了 ReHash 的步骤。让我们回顾一下 ReHash 的代码：

假如此时线程 B 遍历到 Entry3 对象，刚执行完红框里的这行代码，线程就被挂起。对于线程 B 来说：

e = Entry3

next = Entry2

这时候线程 A 畅通无阻地进行着 Rehash，当 ReHash 完成后，结果如下（图中的 e 和 next，代表线程 B 的两个引用）：

直到这一步，看起来没什么毛病。接下来线程 B 恢复，继续执行属于它自己的 ReHash。线程 B 刚才的状态是：

e = Entry3

next = Entry2

当执行到上面这一行时，显然 i = 3，因为刚才线程 A 对于 Entry3 的 hash 结果也是 3。

我们继续执行到这两行，Entry3 放入了线程 B 的数组下标为 3 的位置，并且 e 指向了 Entry2。此时 e 和 next 的指向如下：

e = Entry2

next = Entry2

整体情况如图所示：

接着是新一轮循环，又执行到红框内的代码行：

e = Entry2

next = Entry3

整体情况如图所示：

接下来执行下面的三行，用头插法把 Entry2 插入到了线程 B 的数组的头结点：

整体情况如图所示：

第三次循环开始，又执行到红框的代码：

e = Entry3

next = Entry3.next = null

最后一步，当我们执行下面这一行的时候，见证奇迹的时刻来临了：

newTable[i] = Entry2

e = Entry3

Entry2.next = Entry3

Entry3.next = Entry2

链表出现了环形！

整体情况如图所示：

此时，问题还没有直接产生。当调用 Get 查找一个不存在的 Key，而这个 Key 的 Hash 结果恰好等于 3 的时候，由于位置 3 带有环形链表，所以程序将会进入死循环！