HashMap

HashMap

要求

• 掌握 HashMap 的基本数据结构
• 掌握树化
• 理解索引计算方法、二次 hash 的意义、容量对索引计算的影响
• 掌握 put 流程、扩容、扩容因子
• 理解并发使用 HashMap 可能导致的问题
• 理解 key 的设计

1）基本数据结构

• 1.7 数组 + 链表
• 1.8 数组 + （链表 | 红黑树）

更形象的演示，见资料中的 hash-demo.jar，运行需要 jdk14 以上环境，进入 jar 包目录，执行下面命令

java -jar --add-exports java.base/jdk.internal.misc=ALL-UNNAMED hash-demo.jar

2）树化与退化

树化意义

• 红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略
• hash 表的查找，更新的时间复杂度是 $O(1)$，而红黑树的查找，更新的时间复杂度是 $O(log_2⁡n )$，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表
• hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小

树化规则

• 当链表长度超过树化阈值 8 时，先尝试扩容来减少链表长度，如果数组容量已经 >=64，才会进行树化

退化规则

• 情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表
• 情况2：remove 树节点前时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表

3）索引计算

索引计算方法

• 首先，计算对象的 hashCode()
• 再进行调用 HashMap 的 hash() 方法进行二次哈希
  • 二次 hash() 是为了综合高位数据，让哈希分布更为均匀
    • 为什么？
    • 如果使用原始哈希值直接与 (capacity – 1) 相与 等价于取模 来获得地址，这发现 hash值得高位不参与取模运算只有低位参与，这样的哈希函数我们认为是不好的，它会带来更多的冲突，影响HashMap的效率。通过将哈希码的高16位与低16位进行异或运算，得到一个新的哈希码，这样就可以让高位也参与到运算，这个函数也被称作「扰动函数」
      • 为啥是16位？
      • 如果数组长度是65536，那么只有低16位会参与计算。HashMap取16位是一个折中的数字，绝大部分情况下，HashMap数组的长度都不会超过65536。
      • 1.7 和 1.8 得扰动函数 实现方式不一致，但是基本思想都是让高位参与运算
    • 再将这个扰动函数作为新的hash值与 (capacity – 1) 相与 得到地址
• 最后 & (capacity – 1) 得到索引

数组容量为何是 2 的 n 次幂

1. 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模 如：97%64=33 等价于 97&(64-1) =33
2. 扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap

注意

• 二次 hash 是为了配合 容量是 2 的 n 次幂 这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash
• 容量是 2 的 n 次幂 这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable

4）put 与扩容

初始化 (没有细问就说 默认初始容量16 ，负载因子0.75f)

构造函数1——带指定容量大小和负载因子大小参数的构造函数（容量自动改为大于等于该容量的最小 2得n次数，0.75f）

构造函数2——默认的无参构造函数： （默认容量 16 ，因子默认为 0.75f（没有分配容量）。

构造函数3——带指定容量参数的构造函数 （容量自动改为大于该容量的最小 2得n次数， 0.75f）

构造函数4——传入一个Map集合的构造函数 (容量 max( int (map.size() / 0.75 + 1, 16 ) 得最小二次幂， 0.75）

put 流程

1. HashMap 是懒惰创建数组的，首次使用才创建数组（首次数组容量为16）
2. 计算索引（桶下标）
3. 如果桶下标还没人占用，创建 Node 占位返回
4. 如果桶下标已经有人占用
   1. 已经是 TreeNode 走红黑树的添加或更新逻辑
   2. 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值（链表长度>=8且数组容量大于64），走树化逻辑
5. 返回前检查容量是否超过阈值，一旦超过进行扩容;

1.7 与 1.8 的区别

1. 链表插入节点时，1.7 是头插法，1.8 是尾插法

2. 1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容

3. 1.8 在扩容计算 Node 索引时，会优化

扩容（加载）因子为何默认是 0.75f

1. 在空间占用与查询时间之间取得较好的权衡
2. 大于这个值，空间节省了，但链表就会比较长影响性能
3. 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

HashMap数组的扩容触发条件：

1、HashMap元素个数大于容量的0.75；

2、当添加元素后元素被挂到链表上，且链表长度大于8 ；

5）并发问题

扩容死链（1.7 会存在）

总结：DK7版本中的HashMap扩容时使用头插法，假设此时有元素一指向元素二的链表，当有两个线程使用HashMap扩容的时，若线程一在迁移元素时阻塞，但是已经将指针指向了对应的元素，线程二正常扩容，因为使用的是头插法，迁移元素后将元素二指向元素一。此时若线程一被唤醒，在现有基础上再次使用头插法，将元素一指向元素二，形成循环链表。若查询到此循环链表时，便形成了死锁。而JDK8版本中的HashMap在扩容时保证元素的顺序不发生改变，就不再形成死锁，但是注意此时HashMap还是线程不安全的。

1.7 源码如下：

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;
        }
    }
}

• e 和 next 都是局部变量，用来指向当前节点和下一个节点
• 线程1（绿色）的临时变量 e 和 next 刚引用了这俩节点，还未来得及移动节点，发生了线程切换，由线程2（蓝色）完成扩容和迁移

• 线程2 扩容完成，由于头插法，链表顺序颠倒。但线程1 的临时变量 e 和 next 还引用了这俩节点，还要再来一遍迁移

• 第一次循环
  • 循环接着线程切换前运行，注意此时 e 指向的是节点 a，next 指向的是节点 b
  • e 头插 a 节点，注意图中画了两份 a 节点，但事实上只有一个（为了不让箭头特别乱画了两份）
  • 当循环结束是 e 会指向 next 也就是 b 节点

• 第二次循环
  • next 指向了节点 a
  • e 头插节点 b
  • 当循环结束时，e 指向 next 也就是节点 a

• 第三次循环
  • next 指向了 null
  • e 头插节点 a，a 的 next 指向了 b（之前 a.next 一直是 null），b 的 next 指向 a，死链已成
  • 当循环结束时，e 指向 next 也就是 null，因此第四次循环时会正常退出

数据错乱（1.7，1.8 都会存在）

• 代码参考 day01.map.HashMapMissData，具体调试步骤参考视频

补充代码说明

• day01.map.HashMapDistribution 演示 map 中链表长度符合泊松分布
• day01.map.DistributionAffectedByCapacity 演示容量及 hashCode 取值对分布的影响
  • day01.map.DistributionAffectedByCapacity#hashtableGrowRule 演示了 Hashtable 的扩容规律
  • day01.sort.Utils#randomArray 如果 hashCode 足够随机，容量是否是 2 的 n 次幂影响不大
  • day01.sort.Utils#lowSameArray 如果 hashCode 低位一样的多，容量是 2 的 n 次幂会导致分布不均匀
  • day01.sort.Utils#evenArray 如果 hashCode 偶数的多，容量是 2 的 n 次幂会导致分布不均匀
  • 由此得出对于容量是 2 的 n 次幂的设计来讲，二次 hash 非常重要
• day01.map.HashMapVsHashtable 演示了对于同样数量的单词字符串放入 HashMap 和 Hashtable 分布上的区别

6）key 的设计

key 的设计要求

1. HashMap 的 key 可以为 null，但 Map 的其他实现则不然
2. 作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）
3. key 的 hashCode 应该有良好的散列性

如果 key 可变，例如修改了 age 会导致再次查询时查询不到

public class HashMapMutableKey {
    public static void main(String[] args) {
        HashMap<Student, Object> map = new HashMap<>();
        Student stu = new Student("张三", 18);
        map.put(stu, new Object());

        System.out.println(map.get(stu));

        stu.age = 19;
        System.out.println(map.get(stu));
    }

    static class Student {
        String name;
        int age;

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
}

String 对象的 hashCode() 设计

• 目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特
• 字符串中的每个字符都可以表现为一个数字，称为 $S_i$，其中 i 的范围是 0 ~ n - 1
• 散列公式为： $S_0∗31^{(n-1)}+ S_1∗31^{(n-2)}+ … S_i ∗ 31^{(n-1-i)}+ …S_{(n-1)}∗31^0$
• 31 代入公式有较好的散列特性，并且 31 * h 可以被优化为
  • 即 $32 ∗h -h $
  • 即 $2^5 ∗h -h$
  • 即 $h≪5 -h$

Hashtable vs ConcurrentHashMap

要求

• 掌握 Hashtable 与 ConcurrentHashMap 的区别
• 掌握 ConcurrentHashMap 在不同版本的实现区别

Hashtable

Hashtable 对比 ConcurrentHashMap

• Hashtable 与 ConcurrentHashMap 都是线程安全的 Map 集合
• Hashtable 并发度低，整个 Hashtable 对应一把锁，同一时刻，只能有一个线程操作它
• ConcurrentHashMap 并发度高，整个 ConcurrentHashMap 对应多把锁，只要线程访问的是不同锁，那么不会冲突

ConcurrentHashMap 1.7

• 数据结构：Segment(大数组) + HashEntry(小数组) + 链表，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突
• 并发度：Segment 数组大小即并发度，决定了同一时刻最多能有多少个线程并发访问。Segment 数组不能扩容，意味着并发度在 ConcurrentHashMap 创建时就固定了
• 索引计算
  • 假设大数组长度是 $2^m$，key 在大数组内的索引是 key 的二次 hash 值的高 m 位
  • 假设小数组长度是 $2^n$，key 在小数组内的索引是 key 的二次 hash 值的低 n 位
• 扩容：每个小数组的扩容相对独立，小数组在超过扩容因子时会触发扩容，每次扩容翻倍
• Segment[0] 原型：首次创建其它小数组时，会以此原型为依据，数组长度，扩容因子都会以原型为准

Segment 实现了 ReentrantLock ,所以 Segment 是⼀种可重⼊锁，扮演锁的⻆⾊。 HashEntry ⽤于存储键值对数据。

• ⼀个 ConcurrentHashMap ⾥包含⼀个 Segment 数组。
• 一个 Segment 的结构和 HashMap 类似，是⼀种数组和链表结构。
• ⼀个 Segment 包含⼀个 HashEntry 数组，每个 HashEntry 是⼀个链表结构的元素，每个 Segment 守护着⼀个 HashEntry 数组⾥的元素，当对 HashEntry 数组的数据进⾏修改时，必须⾸先获得对应的 Segment 的锁。

ConcurrentHashMap 1.8

• 数据结构：Node 数组 + 链表或红黑树，数组的每个头节点作为锁，如果多个线程访问的头节点不同，则不会冲突。首次生成头节点时如果发生竞争，利用 cas 而非 syncronized，进一步提升性能
• 并发度：Node 数组有多大，并发度就有多大，与 1.7 不同，Node 数组可以扩容，只要访问的不是同一个链表头就行
• 扩容条件：Node 数组满 3/4 时就会扩容

扩容

举例

1、 put最后一个元素6时，发现需要扩容，会new出一个新的 node数组容量翻倍

• 所谓扩容就是把Node数组里面的每个链表元素 迁移到新 Node数组的过程
• 迁移的过程事宜链表（Node）为单位迁移的，并且是从后向前迁移的

• 首先是15号链表由于时空的瞬间完成，并且做一个收尾工作（处理完的Node替换为ForwardingNode），其他线程来的时候发现这里是ForwardingNode 就说明这里已经处理过了 到新的 ConcurrentHashMap Node找

  

• 再处理14号链表，重新计算哈希值，处理完之后也替换为ForwardingNode

• 

• 处理10号链表时，对于每一个元素重新计算索引值，重新放置

  

• 当所有的Node 都被ForwardingNode代替了，表明迁移完毕

  

• 扩容单位：以链表为单位从后向前迁移链表，迁移完成的将旧数组头节点替换为 ForwardingNode

扩容时并发问题：

• 扩容时并发 get

  • 根据是否为 ForwardingNode 来决定是在新数组查找还是在旧数组查找，不会阻塞

  • 如果链表长度超过 1，则需要对节点进行复制，怕的是节点迁移后 next 指针改变

  • 如果链表最后几个元素扩容后索引不变，则节点无需复制

• 如下图

• 

• 节点 56 链表最后这两个元素 复制后链接关系不变（索引不变）不用复制，当get时，得到的元素就是原来的元素

• 但对于1234 来说，需要复制，得到的时旧链表的元素，如果 HashMap更新后，再次get对比对象地址，会发现不一样

• 扩容时并发 put
  • 如果 put 的线程与扩容线程操作的链表是同一个，put 线程会阻塞 （put 10 会阻塞）
  • 如果 put 的线程操作的链表还未迁移完成，即头节点不是 ForwardingNode，则可以并发执行（如上面，0-9可以put ）
  • 如果 put 的线程操作的链表已经迁移完成，即头结点是 ForwardingNode，则可以协助扩容 （如上面，11-15 ，会按照新元素的新的哈希值找新的表，并 帮助这个线程 扩容（对0-9 扩容））
• 与 1.7 相比是懒惰初始化
• capacity 代表预估的元素个数，capacity / factory 来计算出初始数组大小，需要贴近 $2^n$
• loadFactor 只在计算初始数组大小时被使用，之后扩容固定为 3/4
• 超过树化阈值时的扩容问题，如果容量已经是 64，直接树化，否则在原来容量基础上做 3 轮扩容