Java8集合之HashMap的hash计算、扩容等问题
参考资料:
《Java 8系列之重新认识HashMap》(作者为美团技术团队)
《Java8的HashMap源码分析》(JKD版本为1.7)
《为什么 HashMap 是线程不安全的》
《为什么Java8中HashMap链表使用红黑树而不是AVL树》
《JDK1.8以后的hashmap为什么在链表长度为8的时候变为红黑树》
《HashMap的"红黑树"链表化条件》
《HashMap中红黑树TreeNode的split()方法源码分析》
写在开头:本文为个人学习笔记,内容比较随意,夹杂个人理解,如有错误,欢迎指正。
周末专门学习了下java8中的HashMap,下面对几个重要知识点做下总结归纳。
本文省略了对HashMap的大体介绍,直接解释java8中的难点,因此阅读此文需要对HashMap有基本的理解,
目录
一、hash及索引下标的计算
二、put方法流程
三、扩容
四、线程安全
(1)多线程下 put 会导致元素丢失
(2)put 和 get 并发时会导致 get 到 null
五、为什么使用红黑树
(1)为什么使用的是红黑树而不是AVL树或者别的什么数据结构
(2)为什么数组大于64且链表大于8时才优化
六、红黑树与链表的互相转化
1、由链表转为红黑树
2、由于红黑树转为链表
(1)删除节点时触发
(2)扩容时触发
前提介绍:
(1)HashMap初始容量16,每次扩容都是2倍,引申得到HashMap的容量必为2的n次幂
(2)负载因子为0.75,该值过大,会导致冲突的几率加大,频繁扩容,过小可能导致空间的浪费
(3)java8中链表长度大于8,且数组长度大于等于64时会转换为红黑树
一、hash及索引下标的计算
我们先从jdk1.7中的hash计算开始讲起:
/*** 返回数组下标*/static int indexFor(int h, int length) {return h & (length-1);}
上文是根据已经计算出的hash值得到索引下标的代码。
length为数组的长度,恒为2的n次幂,因此length-1的二进制表示,除最高位为0外,低位全部为1。假设这里length为8,有2个hash分别为3和15要计算索引,于是有:
length-1 0000 0111
3 0000 0011
--------------------------
& 0000 0011
=3length-1 0000 0111
15 0000 1111
--------------------------
& 0000 0111
=7
我们看到,对于一个长度为length的数组,假设其为2的n次幂,length-1的结果就是n个1,其与任何数(如上图中的3、15)相与的结果都是保留其低位,间接性的实现了取模的效果。但是我们为什么不直接取模呢,这是因为&运算直接使用二进制位计算,能更快的达到效果。由于数组长度恒为2的n次幂,所以该结论必然存在。这也是我们每次扩容都是2倍的原因之一。
在java8中我们采用同样的方法来计算索引下标,只不过计算过程放到了put方法当中。
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);
理解了上面这一点,我们再来看java8中的hash计算:
static final int hash(Object key) { int h;// h = key.hashCode() 为第一步 取hashCode值// h ^ (h >>> 16) 为第二步 高位参与运算return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里对于key.hashcode将其本身与自己无符号右移16位的结果相异或,参考下图。
把哈希值右移 16 位,也就正好是自己长度的一半,之后与原哈希值做异或运算,这样就混合了原哈希值中的高位和低位,不仅保留了低位的信息,还夹杂了高位的特征,大大增加了随机性。
二、put方法流程
下图来自美团技术团队,可以清晰的看出整个流程(注意:下图中链表转换红黑树的条件少了一个节点数大于64,即完整的转换条件为链表长度大于8,且数组长度大于等于64)
上图出自《Java 8系列之重新认识HashMap》
(1)判断键值对数组table[i]是否为空或为null,否则执行resize()进行扩容;
(2)根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向(6),如果table[i]不为空,转向(3);
(3)判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向(4),这里的相同指的是hashCode以及equals;
(4)判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向(5);
(5)遍历table[i],判断链表长度是否大于8且数组长度大于64,满足这两个条件则转为红黑树。在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
(6)插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。
public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;// 步骤1:tab为空则创建if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;// 步骤2:计算index,并对null做处理 if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {Node<K,V> e; K k;// 步骤3:节点key存在,直接覆盖valueif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;// 步骤4:判断该链为红黑树else if (p instanceof TreeNode)e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);// 步骤5:该链为链表else {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);// 链表长度大于8转换为红黑树进行处理if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}// key已经存在直接覆盖valueif (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;// 步骤6:超过最大容量 就扩容if (++size > threshold)resize();afterNodeInsertion(evict);return null;}
三、扩容
依然还是从1.7的扩容源码入手,我们可以看到,内部会新建一个数组,然后通过transfer方法
将原数组中的键值对依次加入到新数组中。
void resize(int newCapacity) { //传入新的容量Entry[] oldTable = table; //引用扩容前的Entry数组int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1),这样以后就不会扩容了return;}Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组transfer(newTable); //!!将数据转移到新的Entry数组里table = newTable; //HashMap的table属性引用新的Entry数组threshold = (int)(newCapacity * loadFactor);//修改阈值}void transfer(Entry[] newTable) {Entry[] src = table; //src引用了旧的Entry数组int newCapacity = newTable.length;for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素if (e != null) {src[j] = null;//释放旧Entry数组的对象引用(for循环后,旧的Entry数组不再引用任何对象)do {Entry<K,V> next = e.next;int i = indexFor(e.hash, newCapacity); //!!重新计算每个元素在数组中的位置e.next = newTable[i]; //标记[1]newTable[i] = e; //将元素放在数组上e = next; //访问下一个Entry链上的元素} while (e != null);}}}
我们可以看到,transfer方法会遍历旧数组,对于每个数组元素,会遍历其中的每个节点,并重新计算其hash值,然后使用头插法将其插入到新的索引位置上。
假设现在size=2, 所以key = 3、7、5,扩容的过程如下。
我们发现一个有趣的现象,7、3都刚好移动了2位,刚好是扩容的大小,即2位,这里我们再结合二进制位来看下:
由于扩容直接加了1倍,因此相当于length-1原来的最右侧的0变为了1,因此大于length-1的值,同一的位置下的1也被释放,相当于在原位置+原容量的位置。
因此,我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”
这个设计非常的巧妙,既省去了重新计算hash值的时间,而且同时,由于新增的1bit是0还是1可以认为是随机的,因此resize的过程,均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别,JDK1.7中rehash的时候,旧链表迁移新链表的时候,如果在新表的数组索引位置相同,则链表元素会倒置,但是从上图可以看出,JDK1.8不会倒置。
final Node<K,V>[] resize() {Node<K,V>[] oldTab = table;int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;if (oldCap > 0) {// 超过最大值就不再扩充了,任由其冲突if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}// 没超过最大值,就扩充为原来的2倍else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)newThr = oldThr << 1; // double threshold}else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;else { // zero initial threshold signifies using defaults// 使用无参构造方法生成的HashMap在这里初始化table// 在真正使用到的时候才初始化,避免了空间的浪费newCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}// 计算新的resize上限if (newThr == 0) {float ft = (float)newCap * loadFactor;newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);}threshold = newThr;@SuppressWarnings({"rawtypes","unchecked"})Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];table = newTab;if (oldTab != null) {// 把每个bucket都移动到新的buckets中for (int j = 0; j < oldCap; ++j) {Node<K,V> e;if ((e = oldTab[j]) != null) {oldTab[j] = null;if (e.next == null)newTab[e.hash & (newCap - 1)] = e;// 拆分红黑树else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);else { // preserve order// 链表优化重hash的代码块Node<K,V> loHead = null, loTail = null;Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;do {// 原索引next = e.next;if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}// 原索引+oldCapelse {if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);// 原索引放到bucket里if (loTail != null) {loTail.next = null;newTab[j] = loHead;}// 原索引+oldCap放到bucket里if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}return newTab;}
从源码中我们看到,1.8中采用了尾插法来实现迁移。
四、线程安全
众所周知,HashMap是线程不安全的,虽然有modCount来记录HashMap内部结构发生变化的次数,但却无法保证值的变化的安全。内部结构发生变化指的是结构发生变化,例如put新键值对,但是某个key对应的value值被覆盖不属于结构变化。
这里插个题外话,1.7版本有个著名的结构变化的风险,就是头插法带来的死循环问题,不过这个问题由于1.8采取了新的扩容方法而修复了,所以这里不做额外赘述,有兴趣的可以自行了解。
(1)多线程下 put 会导致元素丢失
多线程同时执行 put 操作时,如果计算出来的索引位置是相同的,那会造成前一个 key 被后一个 key 覆盖,从而导致元素的丢失。
(2)put 和 get 并发时会导致 get 到 null
线程 A 执行put时,因为元素个数超出阈值而出现扩容,线程B 此时执行get。当线程 A 执行完 table = newTab 之后,线程 B 中的 table 此时也发生了变化,此时去 get 的时候就会 get 到 null 了,因为元素还没有迁移完成。
五、为什么使用红黑树
这个问题还可以细分为2个问题
(1)为什么使用的是红黑树而不是AVL树或者别的什么数据结构
因为虽然两者都能实现快速的查找(O(logN)),但是AVL追求的是绝对的平衡,这就导致每次增删操作都会引起AVL树结构的变化,需要O(logN)的时间来旋转,重建结构。而红黑树追求的是相对的平衡,最多两次旋转使其达到平衡(尽管可能需要检查O(logN)节点以确定旋转的位置)。旋转本身是O(1)操作,因为你只是移动指针。
(2)为什么数组大于64且链表大于8时才优化
简单来说,就是树的节点大小是正常大小的2倍,很消耗内存,因此进行了一定的平衡。在hash散列较为均匀的时候是不会利用到红黑树的。
六、红黑树与链表的互相转化
1、由链表转为红黑树
链表长度大于8,且数组长度大于等于64时会转换为红黑树
有的文章里说等于7即可,实际上是错的
遍历过程中p从第一个节点遍历到最后一个节点,但由于binCount是从0开始计数,所以在做树化判断时binCount的值等于 链表长度 - 1(注意此时的链表长度没有算新插入的节点)
但此时链表新插入了一个节点
p.next = newNode(hash, key, value, null);
所以链表树化的那一刻,它的真实长度是binCount(7)+1(新增节点)+1=>TREEIFY_THRESHOLD(8)
即:链表长度大于8时,treeifyBin()方法被调用
2、由于红黑树转为链表
(1)删除节点时触发
删除节点时,判断为红黑树,则会判断根节点、左右孩子以及左孙子节点是否为空,满足其一则认为红黑树中节点较少,已没有维持红黑树的必要,转换为链表。
if (root == null || root.right == null ||(rl = root.left) == null || rl.left == null) {tab[index] = first.untreeify(map); // too smallreturn;
}
(2)扩容时触发
第一步:遍历当前下标中所有节点,通过(hash & bit)得出的高位为0还是1得到2条链表。
第二步:
1、低位链表不为null,且长度小于等于6时,低位链表开始去树化操作。
2、低位链长度大于6,且高位链表不为空,低位链表进行树化
3、高位链表不为null,且长度小于等于6时,高位链表开始去树化操作。
4、高位链长度大于6,且低位链表不为空,高位链进行树化
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {TreeNode<K,V> b = this;// Relink into lo and hi lists, preserving orderTreeNode<K,V> loHead = null, loTail = null;TreeNode<K,V> hiHead = null, hiTail = null;int lc = 0, hc = 0;for (TreeNode<K,V> e = b, next; e != null; e = next) {next = (TreeNode<K,V>)e.next;e.next = null;if ((e.hash & bit) == 0) {//区分树链表的高低位if ((e.prev = loTail) == null)//低位尾部标记为null,表示还未开始处理,此时e是第一个要处理的低位树链表//节点,故e.prev等于loTail都等于nullloHead = e;//低位树链表的第一个树链表节点elseloTail.next = e;loTail = e;++lc;//低位树链表元素个数计数}else {if ((e.prev = hiTail) == null)hiHead = e;//高位树链表的第一个树链表节点elsehiTail.next = e;hiTail = e;++hc;//高位树链表元素个数计数}}if (loHead != null) {//低位树链表不为nullif (lc <= UNTREEIFY_THRESHOLD)//低位树链表元素个数若小于等于6tab[index] = loHead.untreeify(map);//开始去树化操作(就是将元素TreeNode节点都转换成Node节点)else {tab[index] = loHead;if (hiHead != null) // (else is already treeified) //若高位数链表头节点为空,说明还没有处理完高位//,还不能进行树化操作loHead.treeify(tab);//低位树链表元素个数若大于6且高位树链表头节点不等于null,开始将低位树链表真//正树化成红黑树(前面都只是挂着TreeNode的名号,但实际只是链表结构,还没包含红黑树的特性,//在这里才赋予了它红黑树的特性)}}if (hiHead != null) {//高位树链表不为nullif (hc <= UNTREEIFY_THRESHOLD)//高位树链表元素个数若小于等于6tab[index + bit] = hiHead.untreeify(map);//开始去树化操作(就是将元素TreeNode节点都转换成Node节点)else {tab[index + bit] = hiHead;if (loHead != null) //若低位数链表头节点为空,说明还没有处理完低位,还不能进行树化操作hiHead.treeify(tab);//高位树链表元素个数若大于6且低位树链表头节点不等于null,//开始将高位树链表真正树化成红黑树}}}
补充:
为什么负载因子是0.75?
很多文章中都提到了泊松分布和二项分布,但说实话,本人概率论学的实在不咋地,只能简要的概括为性能的折中考虑。
如果有想了解的朋友可以参考这边文章《HashMap的负载因子为什么是0.75》
Java8集合之HashMap的hash计算、扩容等问题相关推荐
- 调试JDK源码-一步一步看HashMap怎么Hash和扩容
调试JDK源码-一步一步看HashMap怎么Hash和扩容 调试JDK源码-ConcurrentHashMap实现原理 调试JDK源码-HashSet实现原理 调试JDK源码-调试JDK源码-Hash ...
- 【数据结构】30、hashmap=》hash 计算方式
前提知识 写在前面,为什么num&(length - 1) 在length是2的n次幂的时候等价于num%length n - 1意味着比n最高位小的位都为1,而高的位都为0,因此通过与可以剔 ...
- Java集合—HashMap为什么2倍扩容
原文作者:很閒很快樂 原文地址:HashMap初始容量为什么是2的n次幂及扩容为什么是2倍的形式 HashMap的初始容量都是2的n次幂的形式存在的,而扩容也是2倍的原来的容量进行扩容,也就是扩容后的 ...
- java8特性快速对list集合的筛选过滤和计算
java8特性快速对list集合的筛选过滤和计算 一.准备工作 1.创建一个Student对象 package com.shiro.test.java8特性;import java.io.Serial ...
- hashmap删除指定key_Java集合之HashMap源码解析(JDK8)
哈希表(hash table)也叫散列表,是一种非常重要的数据结构,应用场景非常丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,而HashMap的实现原理也常常出 ...
- 【集合】 HashMap 你知道多少 ?
最近应粉丝要求,讲一讲集合中的 HashMap, 当然 HashMap 也是面试中经常被问到的一点,如图: 0. HashMap 特点 hashmap存取是无序的 键和值位置都可以是null,但是键位 ...
- Java8中的HashMap分析
本篇文章是网上多篇文章的精华的总结,结合自己看源代码的一些感悟,其中线程安全性和性能测试部分并未做实践测试,直接是"拿来"网上的博客的. 哈希表概述 哈希表本质上一个数组,数组中每 ...
- HashMap解决hash冲突的方法
HashMap解决hash冲突的方法 博客分类: jvm虚拟机 在Java编程语言中,最基本的结构就是两种,一种是数组,一种是模拟指针(引用),所有的数据结构都可以用这两个基本结构构造,HashMap ...
- Java集合:HashMap源码剖析
一.HashMap概述 二.HashMap的数据结构 三.HashMap源码分析 1.关键属性 2.构造方法 3.存储数据 4.调整大小 5.数据读取 ...
最新文章
- Apache,php配置
- svg 转图标字体制作
- linux挂载一个文件夹,linux挂载一个文件夹到另一个文件夹
- 彻底搞清楚map和flatmap
- java命令框编译代码的方式_在命令行模式下如何编译运行Java代码
- 阿里的事前验尸_(不太完全)100天的代码-验尸
- 软件测试都有哪些证书,软件测试都有哪些证书呀?有用吗?
- linux配置apache2
- iterator adapter reverse_iterator
- HDU2516 取石子游戏【博弈】
- Jquery之append()和html()的区别
- 3.自编码器(变分自编码器,VAE)
- 不只是整体OTA,原生全宅智能颠覆了我的想象!
- Javascript实现用户注册验证
- 办公室计算机设备搬迁计划方案,计算机机房整体搬迁方案稿 执行计划.doc
- 太实用了!这几个Python数据可视化案例!(文末送书)
- matlab 共轭,求解线性方程组 - 双共轭梯度法
- 安卓玩机搞机技巧综合资源-----修改rom 制作rom 解包rom的一些问题解析【二十一】
- 长江存储推全新3D NAND架构 挑战三星存储
- Java 删除文件/文件夹