【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别

目录

一、resize()方法执行流程

二、resize()方法源码

2.1 计算新索引的位置(e.hash & oldCap)

三、对比JDK1.7的resize()扩容方法源码

3.1 JDK1.7的resize()方法执行流程

3.2 JDK1.7的resize()方法源码

3.3 initHashSeedAsNeeded()方法源码

3.4  jdk1.7和jdk1.8的区别


下面看一下 resize 方法,面试时最经常问的hashmap扩容机制就在这个地方,注意newCap = oldCap << 1这句,扩容就在这,扩大两倍。

进行扩容,会伴随着一次重新 hash 分配,并且会遍历 hash 表中所有的元素,是非常耗时的。在编写程序中,要尽量避免 resize。

一、resize()方法执行流程

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第1张图片

二、resize()方法源码

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 * 初始化或把table容量翻倍。如果table是空,则根据threshold属性的值去初始化HashMap的容                
 * 量。如果不为空,则进行扩容,因为我们使用2的次幂来给HashMap进行扩容,所以每个桶里的元素 
 * 必须保持在原来的位置或在新的table中以2的次幂作为偏移量进行移动
 * @return 返回Node数组
 */
final Node[] resize() {
    // 创建一个临时变量,用来存储当前的table
    Node[] oldTab = table;
    // 获取原来的table的长度(大小),判断当前的table是否为空,如果为空,则把0赋值给新定义的oldCap,否则以table的长度作为oldCap的大小
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 创建临时变量用来存储旧的阈值,把旧table的阈值赋值给oldThr变量
    int oldThr = threshold;
    // 定义变量newCap和newThr来存放新的table的容量和阈值,默认都是0
    int newCap, newThr = 0;    
    // 判断旧容量是否大于0            
    if (oldCap > 0) {                            
        // 判断旧容量是否大于等于 允许的最大值,2^30
        if (oldCap >= MAXIMUM_CAPACITY) {    
            // 以int的最大值作为原来HashMap的阈值,这样永远达不到阈值就不会扩容了
            threshold = Integer.MAX_VALUE; 
            // 因为旧容量已经达到了最大的HashMap容量,不可以再扩容了,将阈值变成最大值之后,将原table返回       
            return oldTab;
        }
        // 如果原table容量不超过HashMap的最大容量,将原容量*2 赋值给变量newCap,如果newCap不大于HashMap的最大容量,并且原容量大于HashMap的默认容量
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 将newThr的值设置为原HashMap的阈值*2
            newThr = oldThr << 1; // double threshold
    }
    // 如果原容量不大于0,即原table为null,则判断旧阈值是否大于0 
    else if (oldThr > 0) // 如果原table为Null且原阈值大于0,说明当前是使用了构造方法指定了容量大小,只是声明了HashMap但是还没有真正的初始化HashMap(创建table数组),只有在向里面插入数据才会触发扩容操作进而进行初始化
        // 将原阈值作为容量赋值给newCap当做newCap的值。由之前的源码分析可知,此时原阈值存储的大小就是调用构造函数时指定的容量大小,所以直接将原阈值赋值给新容量
        newCap = oldThr;
    // 如果原容量不大于0,并且原阈值也不大于0。这种情况说明调用的是无参构造方法,还没有真正初始化HashMap,只有put()数据的时候才会触发扩容操作进而进行初始化
    else {               // zero initial threshold signifies using defaults
        // 则以默认容量作为newCap的值
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 以初始容量*默认负载因子的结果作为newThr值
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 经过上面的处理过程,如果newThr值为0,说明上面是进入到了原容量不大于0,旧阈值大于0的判断分支。需要单独给newThr进行赋值
    if (newThr == 0) {
        // 临时阈值 = 新容量 * 负载因子
        float ft = (float)newCap * loadFactor;
        // 设置新的阈值 保证新容量小于最大总量   阈值要小于最大容量,否则阈值就设置为int最大值
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
    }
    // 将新的阈值newThr赋值给threshold,为新初始化的HashMap来使用
    threshold = newThr;
    // 初始化一个新的容量大小为newCap的Node数组
    @SuppressWarnings({"rawtypes","unchecked"})
        Node[] newTab = (Node[])new Node[newCap];
    // 将新创建的数组赋值给table,完成扩容后的新数组创建
    table = newTab;
    // 如果旧table不为null,说明旧HashMap中有值
    if (oldTab != null) {
        // 如果原来的HashMap中有值,则遍历oldTab,取出每一个键值对,存入到新table        
        for (int j = 0; j < oldCap; ++j) {
            // 创建一个临时变量e用来指向oldTab中的第j个键值对,
            Node e;
            // 将oldTab[j]赋值给e并且判断原来table数组中第j个位置是否不为空
            if ((e = oldTab[j]) != null) {    
                // 如果不为空,则将oldTab[j]置为null,释放内存,方便gc
                oldTab[j] = null;   
                // 如果e.next = null,说明该位置的数组桶上没有连着额外的数组          
                if (e.next == null)
                    // 此时以e.hash&(newCap-1)的结果作为e在newTab中的位置,将e直接放置在新数组的新位置即可          
                    newTab[e.hash & (newCap - 1)] = e; 
                // 否则说明e的后面连接着链表或者红黑树,判断e的类型是TreeNode还是Node,即链表和红黑树判断
                else if (e instanceof TreeNode)  
                    // 如果是红黑树,则进行红黑树的处理。将Node类型的e强制转为TreeNode,之所以能转换是因为TreeNode 是Node的子类
                    // 拆分树,具体源码解析会在后面的TreeNode章节中讲解
                    ((TreeNode)e).split(this, newTab, j, oldCap); 
                // 当前节不是红黑树,不是null,并且还有下一个元素。那么此时为链表   
                else { // preserve order 
                    /*
                        这里定义了五个Node变量,其中lo和hi是,lower和higher的缩写,也就是高位和低位,
                        因为我们知道HashMap扩容时,容量会扩到原容量的2倍,
                        也就是放在链表中的Node的位置可能保持不变或位置变成 原位置+oldCap,在原位置基础上又加了一个数,位置变高了,
                        这里的高低位就是这个意思,低位指向的是保持原位置不变的节点,高位指向的是需要更新位置的节点
                    */
                    // Head指向的是链表的头节点,Tail指向的是链表的尾节点
                    Node loHead = null, loTail = null;
                    Node hiHead = null, hiTail = null;
                    // 指向当前遍历到的节点的下一个节点
                    Node next;
                    // 循环遍历链表中的Node
                    do {                   
                        next = e.next;
                        /*
                            如果e.hash & oldCap == 0,注意这里是oldCap,而不是oldCap-1。
                            我们知道oldCap是2的次幂,也就是1、2、4、8、16...转化为二进制之后,
                            都是最高位为1,其它位为0。所以oldCap & e.hash 也是只有e.hash值在oldCap二进制不为0的位对应的位也不为0时,
                            才会得到一个不为0的结果。举个例子,我们知道10010 和00010 与1111的&运算结果都是 0010  ,
                            但是110010和010010与10000的运算结果是不一样的,所以HashMap就是利用这一点,
                            来判断当前在链表中的数据,在扩容时位置是保持不变还是位置移动oldCap。
                        */
                        // 如果结果为0,即位置保持不变  
                        if ((e.hash & oldCap) == 0) {  
                            // 如果是第一次遍历    
                            if (loTail == null)      
                                // 让loHead = e,设置头节点     
                                loHead = e;               
                            else
                                // 否则,让loTail的next = e
                                loTail.next = e;   
                            // 最后让loTail = e       
                            loTail = e;                   
                        }
                        /*
                            其实if 和else 中做的事情是一样的,本质上就是将不需要更新位置的节点加入到loHead为头节点的低位链表中,将需要更新位置的节点加入到hiHead为头结点的高位链表中。
                            我们看到有loHead和loTail两个Node,loHead为头节点,然后loTail是尾节点,在遍历的时候用来维护loHead,即每次循环,
                            更新loHead的next。我们来举个例子,比如原来的链表是A->B->C->D->E。
                            我们这里把->假设成next关系,这五个Node中,只有C的hash & oldCap != 0 ,
                            然后这个代码执行过程就是:
                            第一次循环: 先拿到A,把A赋给loHead,然后loTail也是A
                            第二次循环: 此时e的为B,而且loTail != null,也就是进入上面的else分支,把loTail.next =                     
                                        B,此时loTail中即A->B,同样反应在loHead中也是A->B,然后把loTail = B
                            第三次循环: 此时e = C,由于C不满足 (e.hash & oldCap) == 0,进入到了我们下面的else分支,其 
                                        实做的事情和当前分支的意思一样,只不过维护的是hiHead和hiTail。
                            第四次循环: 此时e的为D,loTail != null,进入上面的else分支,把loTail.next =                     
                                        D,此时loTail中即B->D,同样反应在loHead中也是A->B->D,然后把loTail = D
                        */
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 遍历结束,即把table[j]中所有的Node处理完
                    // 如果loTail不为空,也保证了loHead不为空
                    if (loTail != null) {    
                        // 此时把loTail的next置空,将低位链表构造完成    
                        loTail.next = null;    
                        // 把loHead放在newTab数组的第j个位置上,也就是这些节点保持在数组中的原位置不变
                        newTab[j] = loHead;      
                    }
                    // 同理,只不过hiHead中节点放的位置是j+oldCap
                    if (hiTail != null) {       
                        hiTail.next = null;
                        // hiHead链表中的节点都是需要更新位置的节点
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    // 最后返回newTab
    return newTab;            
}

 resize()方法中有几个点需要注意:

  • 一个是计算新索引的位置(e.hash & oldCap),
  • 另一个是红黑树的处理(split)。

下面就就来说一下第一个问题,红黑树处理留到TreeNode的文章讲解。

2.1 计算新索引的位置(e.hash & oldCap

关于e.hash & oldCap == 0 的讲解在之前的HashMap底层原理概要笔记和上面的代码注释中已经说过了,这里再结合图详细说一下。

为什么是e.hash & oldCap 来确定在新数组中的索引位置呢,因为在put 的时候 (n - 1) & hash 得到索引位置

举个例子,扩容前 table 的容量n为16,a 节点和 b 节点在扩容前处于同一索引位置。

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第2张图片

 扩容后,table 长度n为32,新表的 n - 1 只比老表的 n - 1 在高位多了一个1(图中标红的1)。

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第3张图片

 因为 2 个节点在老表是同一个索引位置,因此计算新表的索引位置时,只取决于新表在高位多出来的这一位(图中标红1),而这一位的值刚好等于 oldCap。

因此会存在两种情况:

  1. (e.hash & oldCap) == 0 ,则新表索引位置为“原索引位置” ;
  2. (e.hash & oldCap) != 0,则新表索引位置为”原索引 + oldCap 位置”。

三、对比JDK1.7resize()扩容方法源码

JDK1.7中一般是在进行put()数据的时候调用resize()方法进行扩容,由addEntry()方法进行调用。

3.1 JDK1.7resize()方法执行流程

流程图:

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第4张图片

扩容过程中的转移数据示意图如下:

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第5张图片

在扩容resize()过程中,在将旧数组上的数据转移到新数组上时,转移操作 = 按旧链表的正序遍历链表,在新链表的使用头插法依次插入,即在转移数据、扩容后,容易出现链表逆序的情况。

此时若(多线程)并发执行 put()操作,一旦出现扩容情况, 容易出现环形链表,从而在获取数据、遍历链表时形成死循环(Infinite Loop),即死锁的状态,所以HashMap线程不安全。

3.2 JDK1.7resize()方法源码

/**
* 分析:resize(2 * table.length)
* 作用:当容量不足时(容量 > 阈值),则扩容(扩到2倍)
*/   
void resize(int newCapacity) {  
    // 1. 保存旧数组(old table)
    Entry[] oldTable = table; 
    // 2. 保存旧容量(old capacity ),即数组长度
    int oldCapacity = oldTable.length;
    // 3. 若旧容量已经是系统默认最大容量了,那么将阈值设置成整型的最大值,退出    
    if (oldCapacity == MAXIMUM_CAPACITY) {
        // 修改扩容阀值  
        threshold = Integer.MAX_VALUE;
        return;  
    }  
    // 4. 根据新容量(2倍容量)新建1个数组,即新table  
    Entry[] newTable = new Entry[newCapacity];  
    // 5. 将旧数组上的数据(键值对)转移到新table中,从而完成扩容。initHashSeedAsNeeded(newCapacity)这个方法用来根据新的数组长度来重新初始化Hash种子
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    // 6. 新数组table引用到HashMap的table属性上
    table = newTable;  
    // 7. 重新设置阈值,如果阈值超过了HashMap最大容量大小,则直接将阈值设置为 MAXIMUM_CAPACITY + 1
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}  

 如果数组进行扩容,数组长度发生变化,而存储位置 index = h&(length-1),index也可能会发生变化,需要重新计算index,我们先来看看transfer这个方法:

/**
* 分析:transfer(newTable); 
* 作用:将旧数组上的数据(键值对)转移到新table中,从而完成扩容
* 过程:按旧链表的正序遍历链表、在新链表的头部依次插入
* @param rehash 如果这里传入的是true,说明Hash种子已经更新,需要对所有的元素进行rehash重新计算Hash值。该操作比较消耗资源,这也是JDK1.7相对JDK1.8执行效率较低的原因
*/ 
void transfer(Entry[] newTable, boolean rehash) {  
    // 获取新数组的大小 = 获取新容量大小   
    int newCapacity = newTable.length
    // 通过遍历 旧数组,将旧数组上的数据(键值对)转移到新数组中
    for (Entry e : table) {
        // 遍历桶中所有元素
        while(null != e) {  
            Entry next = e.next;  
            // 如果是重新Hash,则需要重新计算hash值  
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);  
            }  
            // 重新计算每个元素的存储位置,这里再次按照之前计算元素所在位置的方法重新进行一遍 Hash值 &(新数组长度 - 1)的计算,也是相当消耗资源的操作。1.8就采用扩容之后运用运算规律来对元素重新定位,这样相对要高效很多。
            int i = indexFor(e.hash, newCapacity);
            // 将元素放在数组上:采用单链表的头插入方式 = 在链表头上存放数据 = 将新插入数据的next指向原数组位置的链表头节点,然后将需放入的数据放到数组位置中,这样就实现了头插法将数据插入链表
            // 即 扩容后,可能出现逆序:按旧链表的正序遍历链表、在新链表的头部依次插入
            e.next = newTable[i];
            // newTable[i]的值总是最新插入的值
            newTable[i] = e;
            // 访问下一个Entry链上的元素,如此不断循环,直到遍历完该链表上的所有节点
            e = next;
        }  
    }  
}  

3.3 initHashSeedAsNeeded()方法源码

这个方法在JDK1.7中inflateTable()初始化哈希表方法和resize()扩容方法中都有出现。这个方法作用是初始化Hash种子。在JDK1.7中计算hash值的方法需要使用Hash种子来参与运算,进而提高计算出来的hash值的散列性,最大限度减少哈希冲突。下面就来简单讲一下这个方法。

/**
 * 这个方法用来根据新的数组长度来重新初始化Hash种子,好的Hash种子能提高计算Hash时结果的散列性,最大限度减少哈希冲突。
 * @param capacity 根据传入的容量大小来进行重新初始化Hash种子
 * @return 返回true说明已经根据传入的容量大小重新初始化了Hash种子,此时以前根据旧的Hash种子计算出来的Hash值就需要进行rehash了。
 *         返回false说明并没有根据传入的容量大小进行重新初始化Hash种子
 */
final boolean initHashSeedAsNeeded(int capacity) {
    // 首先会判断hashSeed是否不等于0,因为hashSeed一开始是0,所以此处是false
    boolean currentAltHashing = hashSeed != 0;
    // 这行代码是判断vm是否启动 且 容量到达一个值ALTERNATIVE_HASHING_THRESHOLD,这个值是可以自己去设定,不设定的话是默认的Integer.MaxValue 。 假设我们初始化容量capacity = 16,设置ALTERNATIVE_HASHING_THRESHOLD值为 3,那么这行代码会为true
    boolean useAltHashing = sun.misc.VM.isBooted() &&
        (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    //亦或 ^ 的意思是 不相同则返回true,此时switching=true,那么hashSeed就会重新去计算hash种子,以便计算hash时增加散列性,
    boolean switching = currentAltHashing ^ useAltHashing;
    if (switching) {
        // 重新设置了Hash种子
        hashSeed = useAltHashing
            ? sun.misc.Hashing.randomHashSeed(this)
            : 0;
    }
    return switching;
}

final int hash(Object k) {
    // 设置了哈希种子
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }
    // Hash种子参与到了key的Hash值计算当中
    h ^= k.hashCode();
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

3.4  jdk1.7jdk1.8的区别

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别_第6张图片

resize()扩容方法会触发一系列的TreeNode类的方法,依次为:split()、untreeify()、treeify()、tieBreakOrder()、balanceInsertion()、moveRootToFront()、checkInvariants() 。这些方法源码的详细讲解可以看这篇文章:【Java集合】HashMap的扩容操作源码详解https://blog.csdn.net/cy973071263/article/details/124766292?spm=1001.2014.3001.5501


相关文章: 【Java集合】HashMap系列(一)——底层数据结构分析
                   【Java集合】HashMap系列(二)——底层源码分析
                   【Java集合】HashMap的tableSizeFor()源码详解​​​​​​
                   【Java集合】HashMap的putMapEntries()源码详解 
                   【Java集合】HashMap的put()源码详解以及JDK1.7与JDK1.8的区别 
                   【Java集合】HashMap的get()源码详解以及JDK1.7与JDK1.8的区别 
                   【Java集合】HashMap的remove()源码详解以及JDK1.7与JDK1.8的区别

你可能感兴趣的:(#,Java集合,Java,散列表,java,hashmap,resize,源码)