Map源码解析之HashMap源码分析

实现原理

HashMap 是数组 + 链表 + 红黑树（JDK1.8 增加了红黑树部分）实现的。

HashMap 的工作原理

HashMap 基于 hashing 原理，当我们往 HashMap 中 put 元素时，先根据 key 的 hash 值得到这个 Entry 元素在数组中的位置（即下标），然后把这个 Entry 元素放到对应的位置中，如果这个 Entry 元素所在的位子上已经存放有其他元素就在同一个位子上的 Entry 元素以链表的形式存放，新加入的放在链头( JDK 1.8 以前碰撞节点会在链表头部插入，而 JDK 1.8 开始碰撞节点会在链表尾部插入，对于扩容操作后的节点转移 JDK 1.8 以前转移前后链表顺序会倒置，而 JDK 1.8 中依然保持原序。)，从 HashMap 中 get Entry 元素时先计算 key 的 hashcode，找到数组中对应位置的某一 Entry 元素，然后通过 key 的 equals 方法在对应位置的链表中找到需要的 Entry 元素，所以 HashMap 的数据结构是数组和链表的结合，此外 HashMap 中 key 和 value 都允许为 null，key 为 null 的键值对永远都放在以 table[0] 为头结点的链表中。 HashMap 在每个链表节点中储存键值对对象。

当两个不同的键对象的hashcode相同时会发生什么

它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。

Node[] table 的初始化长度 length (默认值是16)，Load factor 为负载因子(默认值是 0.75 )，threshold 是HashMap 所能容纳的最大数据量的 Node (键值对)个数。

threshold 就是在此 Load factor 和 length (数组长度)对应下允许的最大元素数目，超过这个数目就重新 resize (扩容)，扩容后的 HashMap 容量是之前容量的两倍。

在 HashMap 中，哈希桶数组 table 的长度 length 大小必须为 2 的 n 次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数。

HashMap 采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap 定位哈希桶索引位置时，也加入了高位参与运算的过程。

当链表长度太长（默认超过 8 ）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高 HashMap 的性能。

属性和构造函数

  • 初始容量：表示哈希表在其容量自动增加之前可以达到多满的一种尺度

  • 加载因子：当哈希表中的条目超过了容量和加载因子的乘积的时候，就会进行重哈希操作。

 

  1. //======常量==========
  2. // 默认初始化容量16
  3. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
  4. // 最大容量
  5. static final int MAXIMUM_CAPACITY = 1 << 30;
  6. // 默认负载因子 加载因子过高，容易产生哈希冲突，加载因子过小，容易浪费空间，0.75是一种折中。
  7. static final float DEFAULT_LOAD_FACTOR = 0.75f;
  9. // ======属性=======
  10. transient Node<K,V>[] table; // 哈希桶数组
  11. //
  12. transient Set<Map.Entry<K,V>> entrySet;
  13. // 大小
  14. transient int size;
  15. // 用来记录HashMap内部结构发生变化的次数
  16. transient int modCount;
  17. // 所能容纳的key-value对极限  (int)(capacity * load factor)
  18. int threshold;
  19. //哈希表的装载因子 
  20. final float loadFactor;
 

Node 是 HashMap 的一个内部类，实现了 Map.Entry 接口，本质是就是一个映射(键值对)。
 

 

  1. static class Node<K,V> implements Map.Entry<K,V> {
  2.         final int hash; //用来定位数组索引位置
  3.         final K key;
  4.         V value;
  5.         Node<K,V> next; //链表的下一个node
  7.         Node(int hash, K key, V value, Node<K,V> next) {
  8.             this.hash = hash;
  9.             this.key = key;
  10.             this.value = value;
  11.             this.next = next;
  12.         }
  14.         public final K getKey()        { return key; }
  15.         public final V getValue()      { return value; }
  16.         public final String toString() { return key + "=" + value; }
  18.         public final int hashCode() {
  19.             return Objects.hashCode(key) ^ Objects.hashCode(value);
  20.         }
  22.         public final V setValue(V newValue) {
  23.             V oldValue = value;
  24.             value = newValue;
  25.             return oldValue;
  26.         }
  28.         public final boolean equals(Object o) {
  29.             if (o == this)
  30.                 return true;
  31.             if (o instanceof Map.Entry) {
  32.                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
  33.                 if (Objects.equals(key, e.getKey()) &&
  34.                     Objects.equals(value, e.getValue()))
  35.                     return true;
  36.             }
  37.             return false;
  38.         }
  39.     }
 

hash(Object key)
 

确定哈希桶数组索引位置，本质上就三部：取 key 的 hashCode 值、高位运算、取模运算。
 

 

  1. 方法一：
  2. static final int hash(Object key) {   //jdk1.8 & jdk1.7
  3.     int h;
  4.     // h = key.hashCode() 为第一步 取hashCode值
  5.     // h ^ (h >>> 16)  为第二步 高位参与运算
  6.     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  7. }
  9. 方法二：
  10. static int indexFor(int h, int length) {  
  11. //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
  12.     return h & (length-1);  //第三步 取模运算
  13. }
 

只要它的 hashCode() 返回值相同，那么程序调用方法一所计算得到的 Hash 码值总是相同的。
 

put(K key, V value)
 

 
 
当我们往 HashMap 中 put 元素的时候，先根据 key 的 hashCode 重新计算 hash 值，根据 hash 值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头（1.8 以前），最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。
 

 

 

  1. // 添加一个元素
  2. public V put(K key, V value) {
  3.   // 对key的hashCode()做hash
  4.   return putVal(hash(key), key, value, false, true);
  5. }
  6. // 内部实现
  7. final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
  8.         Node<K,V>[] tab; Node<K,V> p; int n, i;
  9.            // 步骤①：tab为空则创建
  10.         if ((tab = table) == null || (n = tab.length) == 0)
  11.             n = (tab = resize()).length;
  12.           // 步骤②：计算index，并对null做处理
  13.         if ((p = tab[i = (n - 1) & hash]) == null)
  14.             tab[i] = newNode(hash, key, value, null);
  15.         else {
  16.             Node<K,V> e; K k;
  17.           // 步骤③：节点key存在，直接覆盖value
  18.             if (p.hash == hash &&
  19.                 ((k = p.key) == key || (key != null && key.equals(k))))
  20.                 e = p;
  21.           // 步骤④：判断该链为红黑树
  22.             else if (p instanceof TreeNode)
  23.                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
  24.            // 步骤⑤：该链为链表
  25.             else {
  26.                 for (int binCount = 0; ; ++binCount) {
  27.                     if ((e = p.next) == null) {
  28.                         p.next = newNode(hash, key, value, null);
  29.                       // 链表长度大于8转换为红黑树进行处理
  30.                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
  31.                             treeifyBin(tab, hash);
  32.                         break;
  33.                     }
  34.                   // key已经存在直接覆盖value
  35.                     if (e.hash == hash &&
  36.                         ((k = e.key) == key || (key != null && key.equals(k))))
  37.                         break;
  38.                     p = e;
  39.                 }
  40.             }
  41.             if (e != null) { // existing mapping for key
  42.                 V oldValue = e.value;
  43.                 if (!onlyIfAbsent || oldValue == null)
  44.                     e.value = value;
  45.                 afterNodeAccess(e);
  46.                 return oldValue;
  47.             }
  48.         }
  49.         ++modCount;
  50.    // 步骤⑥：超过最大容量 就扩容
  51.         if (++size > threshold)
  52.             resize();
  53.         afterNodeInsertion(evict);
  54.         return null;
  55.     }
 


 

读取 get(Object key)
 

 

  1. // 根据key获取value
  2. public V get(Object key) {
  3.   Node<K,V> e;
  4.   return (e = getNode(hash(key), key)) == null ? null : e.value;
  5. }
  6. // 内部方法
  7. /**
  8.  * Implements Map.get and related methods
  9.  *
  10.  * @param hash hash for key
  11.  * @param key the key
  12.  * @return the node, or null if none
  13.  */
  14. final Node<K,V> getNode(int hash, Object key) {
  15.   Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
  16.   // table有元素
  17.   if ((tab = table) != null && (n = tab.length) > 0 &&
  18.       (first = tab[(n - 1) & hash]) != null) {
  19.     // 从第1个node开始
  20.     if (first.hash == hash && // always check first node
  21.         ((k = first.key) == key || (key != null && key.equals(k))))
  22.       return first;
  23.     // first的下一个node
  24.     if ((e = first.next) != null) {
  25.       // 若是链表
  26.       if (first instanceof TreeNode)
  27.         return ((TreeNode<K,V>)first).getTreeNode(hash, key);
  28.       //  否则循环查找
  29.       do {
  30.         if (e.hash == hash &&
  31.             ((k = e.key) == key || (key != null && key.equals(k))))
  32.           return e;
  33.       } while ((e = e.next) != null);
  34.     }
  35.     // 就一个node，first，取的还不是它，直接退出
  36.   }
  37.   // table没元素直接返回null
  38.   return null;
  39. }
 

移除元素remove(Object key)
 

 

  1. // 根据key移除元素，并返回移除的元素
  2. public V remove(Object key) {
  3.   Node<K,V> e;
  4.   return (e = removeNode(hash(key), key, null, false, true)) == null ?
  5.     null : e.value;
  6. }
 

扩容机制resize
 

当元素个数 > 数组大小 （默认 16 ）* 负载因子（默认 0.75f ）时开始扩容，即默认情况下元素个数大于 12 个时，数组大小扩为 2 *16 = 32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 HashMap 中元素的个数，那么预设元素的个数能够有效的提高 HashMap 的性能。
 

使用一个新的数组代替已有的容量小的数组
 

HashMap 并发问题
 

多线程put后可能导致get死循环
 

由于 HashMap 是线程不安全的，高并发情况下会出现死循环，即会出现 环形链表，进而导致 CPU 被占满的情况。
 

具体分析：
 

单线程情况下，HashMap 重复插入某个值的时候，会覆盖之前的值，这个没错。但在多线程访问的时候，由于其内部实现机制(在多线程环境且未作同步的情况下，对同一个 HashMap 做 put 操作可能导致两个或以上线程同时做 rehash 动作，就可能导致循环键表出现，一旦出现线程将无法终止，持续占用 CPU ，导致 CPU 使用率居高不下)，就可能出现安全问题了。
 

办法：使用jstack工具dump出问题的那台服务器的栈信息，查看具体日志信息。
 

注意：不合理使用HashMap导致出现的是死循环而不是死锁。
 

多线程put的时候可能导致元素丢失
 

主要问题出在addEntry方法的new Entry (hash, key, value, e)，如果两个线程都同时取得了e,则他们下一个元素都是e，然后赋值给table元素的时候有一个成功有一个丢失。
 

三种解决方案
 

  • Hashtable替换HashMap
  • Collections.synchronizedMap将HashMap包装起来
  • ConcurrentHashMap替换HashMap （推荐 ）
 

总结
 

  1. 扩容是一个特别耗性能的操作，所以当程序员在使用 HashMap 的时候，估算 map 的大小，初始化的时候给一个大致的数值，避免 map 进行频繁的扩容。
  2. 负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
  3. HashMap 是线程不安全的，不要在并发的环境中同时操作 HashMap，建议使用 ConcurrentHashMap。
  4. JDK1.8 引入红黑树大程度优化了 HashMap 的性能。
  5. 使用可变对象做 Key 会造成 value 找不到的情况，所以使用 String， Integer等不可变类型用作 Key。
 

延伸阅读
 

哈希
 

Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
 

所有散列函数都有如下一个基本特性：根据同一散列函数计算出的散列值如果不同，那么输入值肯定也不同。但是，根据同一散列函数计算出的散列值如果相同，输入值不一定相同。
 

两个不同的输入值，根据同一散列函数计算出的散列值相同的现象叫做碰撞
 

常见的Hash函数有以下几个：
 

 
 
直接定址法：直接以关键字k或者k加上某个常数（k+c）作为哈希地址。
 
 
数字分析法：提取关键字中取值比较均匀的数字作为哈希地址。
 
 
除留余数法：用关键字k除以某个不大于哈希表长度m的数p，将所得余数作为哈希表地址。
 
 
分段叠加法：按照哈希表地址位数将关键字分成位数相等的几部分，其中最后一部分可以比较短。然后将这几部分相加，舍弃最高进位后的结果就是该关键字的哈希地址。
 
 
平方取中法：如果关键字各个部分分布都不均匀的话，可以先求出它的平方值，然后按照需求取中间的几位作为哈希地址。
 
 
伪随机数法：采用一个伪随机数当作哈希函数。
 

 

解决碰撞的方法：
 

1.开放定址法：
 

  • 开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。
 

2.链地址法：
 

  • 将哈希表的每个单元作为链表的头结点，所有哈希地址为i的元素构成一个同义词链表。即发生冲突时就把该关键字链在以该单元为头结点的链表的尾部。
 

3.再哈希法：
 

  • 当哈希地址发生冲突用其他的函数计算另一个哈希函数地址，直到冲突不再产生为止。
 

4.建立公共溢出区
 

  • 将哈希表分为基本表和溢出表两部分，发生冲突的元素都放入溢出表中。
 

原文地址

                





            

            
posted @ 
2020-07-13 18:46 
路暝月 
阅读(5) 
评论(0) 
编辑 
收藏 
举报
 来源