HashMap JDK1.7与1.8的区别

news2024/11/8 11:13:34

结构

首先HashMap在1.7中是以数组+链表的形式存在的, 而HashMap在1.8中则是以数组+链表+红黑树构成的, 当一个节点的链表长度超过8并且数组长度超过64时会将链表转换为红黑树,
在这里插入图片描述

在这里插入图片描述

初始化

初始容量大小介绍
说到数组就不得不提HashMap里面的成员变量DEFAULT_INITIAL_CAPACITY也就是容量大小,如果不指定的话默认是16,如果通过有参构造指定容器大小的话也必须是2的平方数,当然了如果传入的参数并不是2的平方数的话(最好不要这样,实在不知道写多少容量我们直接写个默认的大小16),HashMap会通过方法将它变成比这个数大且离2的平方数最近的数例如传入11他会变成16,之所以要这么做的原因是,根据上述讲解我们已经知道,当向 HashMap 中添加一个元素的时候,需要根据 key 的 hash 值,去确定其在数组中的具体位置。HashMap 为了存取高效,减少碰撞,就是要尽量把数据分配均匀,每个链表长度大致相同,这个实现的关键就在把数据存到哪个链表中的算法。这个算法实际就是取模,hash % length,计算机中直接求余效率不如位移运算。所以源码中做了优化,使用 hash & (length - 1),而实际上 hash % length 等于 hash & ( length - 1) 的前提是 length 是 2 的 n 次幂。并且 length 是 2 的 n 次幂从位运算的角度,length - 1的二进制为全1,hash & ( length - 1)可以尽量减少的hash值的损失,可以做到更好的散列。
上面提到了如果传入的指定大小并不是2的n次幂,HashMap会将大小变成比指定大小大且是2的n次幂的数,我们看看JDK1.7和JDK1.8是如何做的。
JDK1.7

*/
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);

    // Find a power of 2 >= initialCapacity
    int capacity = 1;
    // 从1开始不停的左移也就是变大2的n次幂,直到不比指定容量小
    // 1  2  4  8  16  32.。。。
    while (capacity < initialCapacity)
        capacity <<= 1;

    this.loadFactor = loadFactor;
    threshold = (int)(capacity * loadFactor);
    table = new Entry[capacity];
    init();
}

jdk1.7的方式是从1开始不断进行位运算,一次右移一位,即成一次2直到,计算容量大于传入的initialCapacity
JDK1.8

// 假设cap为13
static final int tableSizeFor(int cap) {
    // n=12 int类型在内存中占4个字节,,一个字节占8位
    int n = cap - 1;
/*
* 00000000 00000000 00000000 00001100   12
* 00000000 00000000 00000000 00000110   右移1位
* ---------------------------------------------- 或运算
* 00000000 00000000 00000000 00001110    14
*/
n |= n >>> 1; // n=14
/*
* 00000000 00000000 00000000 00001110   12
* 00000000 00000000 00000000 00000111   右移2位
* ---------------------------------------------- 或运算
* 00000000 00000000 00000000 00001111    15
*/
n |= n >>> 2;//计算完n=15
/*
* 00000000 00000000 00000000 00001111   15
* 00000000 00000000 00000000 00000000   右移4位
* ---------------------------------------------- 或运算
* 00000000 00000000 00000000 00001111    15
*/
n |= n >>> 4;// 计算完n=15
/*
* 00000000 00000000 00000000 00001111   15
* 00000000 00000000 00000000 00000000   右移8位
* ---------------------------------------------- 或运算
* 00000000 00000000 00000000 00001111    15
*/
n |= n >>> 8;// 计算完n=15
/*
* 00000000 00000000 00000000 00001111   15
* 00000000 00000000 00000000 00000000   右移16位
* ---------------------------------------------- 或运算
* 00000000 00000000 00000000 00001111    15
*/
n |= n >>> 16;// 计算完n=15

return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

JDK1.8中的做法简单来说就是通过位运算将最高非0位后面全置为1**,由上面可以看出通过这五次的计算,最后的结果刚好可以填满32位的空间**,整体思路就是对与当前构造的cap,找到其二进制最高位,不断左移再进行或运算,通过最高位二进制,将最低为都设置为1,最终最高位到地位全为1,最后再加1就得到了一个2得n次方的数。并且比传进来的cap大
至于为什么要减1,因为如果传进来的cap恰好是一个2的n次方的数,那么会得到这个cap*2,因此要位运算前要减1

负载因子和阈值

负载因子static final float DEFAULT_LOAD_FACTOR = 0.75f和阈值int threshold的话是用来给map扩容判断时用的,负载因子也能够在构造函数中进行指定(不推荐),每次进行put的时候都会进行判断是否需要扩容,当size超过了阈值=总容量*负载因子,则会扩容,默认情况下总容量是16,负载因子是0.75,至于为啥是0.75这是由于经过大量的实验证明该系数是最合适的,如果设置过小,HashMap每put少量的数据,都要进行一次扩容,而扩容操作会消耗大量的性能。如果设置过大的话,如果设成1,容量还是16,假设现在数组上已经占用的15个,再要put数据进来,计算数组index时,发生hash碰撞的概率将达到15/16,这违背的HashMap减少hash碰撞的原则。

HashMap构造方法

JDK1.7中的无参构造方法:

/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
    // 负载因子
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    // 阈值:总容量*负载因子
    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
    // 存放键值对的entry
    table = new Entry[DEFAULT_INITIAL_CAPACITY];
    init();
}

JDK1.8中的构造方法:

public HashMap() {
    // 将负载因子设置为默认的0.75f,并没有在构造方法中创建Entry的数组,而是放到put方法中了
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

public HashMap(int initialCapacity, float loadFactor) {
    // 给的初始大小是不是小于0
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    // 是否超过最大容量,是的话则直接赋值最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // 给的加载因子是不是个大于0的数字
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    // 设置加载因子的大小
    this.loadFactor = loadFactor;
    // 调整给定的数组大小
    this.threshold = tableSizeFor(initialCapacity);
}

this.threshold = tableSizeFor(initialCapacity);判断指定的初始化容量是否是2的n次幂,如果不是那么会变为比指定初始化容量大的最小的2的n次幂。但是注意,在tableSizeFor方法体内部将计算后的数据返回给调用这里了,并且直接赋值给threshold边界值了。有些人会觉得这里是一个bug,应该这样书写:this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;这样才符合threshold的意思(当HashMap的size到达threshold这个阈值时会扩容)。但是请注意,在jdk8以后的构造方法中,并没有对table这个成员变量进行初始化table的初始化被推迟到了put方法中,在put方法中会对threshold重新计算。

一个明显区别,jdk1.8在构造时没有初始化table,1.7在构造时就就初始化了

put方法

JDK1.8中的put方法

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
    Node<K,V>[] tab;
.......
}

在put方法中又调用了putVal(hash(key), key, value, false, true);以及hash(key)方法,首先我们先来看下hash(key)方法

static final int hash(Object key) {
        int h;
        // 如果key是null则hash值为0
        //(h = key.hashCode()) ^ (h >>> 16)
        // 先获取key的hashCode并赋值给h, 然后和h和h右移16位后做异或运算得到hash值
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

这里有个步骤(h = key.hashCode()) ^ (h >>> 16),为什么要获取完hashCode()赋值给h后要和h右移16位做异或运算呢,直接让h=key.hashCode()不行吗?实际上这是在进行put操作时尽可能的避免hash冲突,前面说过存放元素的时候寻找数组下标实际上是hash值对数组长度取余,当数组长度为2的n次幂时,(n - 1) & hash和hash%n是等价的而且运算效率比取余高,简单来说之所以这么做就是,高 16bit 不变,低 16bit 和高 16bit 做了一个异或(得到的 hashCode 转化为 32 位二进制,前 16 位和后 16 位低 16bit 和高 16bit 做了一个异或),
hashMap开始是从16开始的,只占了4位二进制,也就是说在32位二进制中,其高位均为0,那么其与hash进行与运算,hash值的高位完全浪费了,因此高16与低16位进行异或运算可以更好的散列hash值。
我们看到真正参与运算的实际上只有最后四位,也就是说其他高位并没有参与运算
那么会出现一种状况,就是调用hashCode()方法获取的值高位不停的在变动但是地位不变,这种状况就会造成(n-1)&hash结果会一致,造成hash冲突。
简单来说就是通过右移16位和异或操作让高位地位都参与了运算尽可能的减少hash冲突

接着看putVal方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        /*
            Node<K,V>[] tab:存放元素的数组
            Node<K,V> p:用来保存索引位置的元素
            int n:n用来记录数组的长度
            int i:i用来记录索引的位置
         */
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        /*
            1.table:transient Node<K,V>[] table; 存放元素的数组
            2.(tab = table) == null 将table赋值给tab并判断是否为null   第一次put必然为null
            3.(n = tab.length) == 0  将数组的长度赋值给n并判断是否为0
         */
        if ((tab = table) == null || (n = tab.length) == 0)
            // tab为null 或者 tab长度为0,进行扩容操作
            n = (tab = resize()).length;
        /*
            (n - 1) & hash:之前说过,当n为2的n次幂时这个操作等价于hash%n,即hash值对数组长度取余
            i = (n - 1) & hash:存放元素的数组索引下标
            索引位置不存在元素,则在索引位置创建一个新节点
            这里会给p进行赋值,不存元素p则为null
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            /* 执行else说明tab[i]不等于null,表示这个位置已经有值了
                Node<K,V> e:保存数据的节点
                K k:保存key
             */
            Node<K,V> e; K k;
            /*
                1.p.hash == hash:p的hash值==传入的hash值
                2.(k = p.key) == key:将p的key赋值给k == 现在的key
                3.key != null && key.equals(k))):key不为空&&key的内容和现在的key的内容相等
                同时满足1、2或者满足3,则将p节点赋值给e
             */
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            /*
                判断p是否为红黑树结点
             */
            else if (p instanceof TreeNode)
                /*
                    往树中插入节点并赋值给e
                 */
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                /*
                    binCount:记录遍历节点的个数
                 */
                for (int binCount = 0; ; ++binCount) {
                    /*
                        1)e = p.next 获取p的下一个元素赋值给e。
                        2)(e = p.next) == null 判断p.next是否等于null,等于null,说明p没有下一个元素,
                        那么此时到达了链表的尾部,还没有找到重复的key,则说明HashMap没有包含该键,将该键值对插入链表中。
                    */
                    if ((e = p.next) == null) {
                        /*
                            最后一个节点了,所以next为null
                            JDK8采用尾插法新增节点,JDK8之前是头插法
                         */
                        p.next = newNode(hash, key, value, null);
                        /*
                            判断是否要转成红黑树
                            binCount是从0开始自增的,当binCount = 7时说明已经有8个节点
                            加上刚刚插入的节点所以是9个,所以当链表长度>8时转成红黑树
                         */
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 转成红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    /*
                	执行到这里说明e = p.next 不是null,不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。
                     */
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        // 相等,跳出循环
                        break;
                    // 将e赋值给p,继续查找下一节点
                    p = e;
                }
            }
            /*
                如果e!=null则说明通过上面的一系列操作,找到了重复的key,所以
                这里就是将key对应的原来的旧值替换成新值并将旧值返回
             */
            if (e != null) { // existing mapping for key
                // 获取旧值
                V oldValue = e.value;
                // onlyIfAbsent为false或者oldValue为null
                if (!onlyIfAbsent || oldValue == null)
                    // 将新值保存
                    e.value = value;
                // 访问后回调,点进去会发现是个空方法,是为了继承HashMap的LinkedHashMap类服务
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        // 这个变量是用来记录修改次数的
        ++modCount;
        // 判断新增元素后的大小是否比阈值大,如果是的话则要进行扩容操作
        if (++size > threshold)
            resize();
        // 插入后回调,点进去会发现是个空方法,是为了继承HashMap的LinkedHashMap类服务
        afterNodeInsertion(evict);
        return null;
    }

转成红黑树的__treeifyBin()__方法

 /**
     * 转成红黑树
     * @param tab
     * @param hash
     */
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        /*
            数组tab不为空或者数组长度小于64则进行扩容操作
            n = tab.length:数组长度赋值给n

         */
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        /*
            转成红黑树操作
            e = tab[index = (n - 1) & hash]):获取索引位置元素
         */
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            /*
                hd:存放树的头结点
                tl:用来存放临时节点
             */
            TreeNode<K,V> hd = null, tl = null;
            do {
                // 将链表节点转成树节点
                TreeNode<K,V> p = replacementTreeNode(e, null);
                /*
                    tl:第一次临时节点必然为空
                    将p节点赋值给头结点
                 */
                if (tl == null)
                    hd = p;
                else {
                    /*
                        临时tl节点不为空:
                        p.prev = tl:将tl赋值给p的prev节点
                        tl.next = p:将p节点赋值给tl的next节点
                     */
                    p.prev = tl;
                    tl.next = p;
                }
                // 将p节点赋值给tl节点
                tl = p;
            } while ((e = e.next) != null); // 循环,直到Next节点不存在
            /*
                (tab[index] = hd):将树的头结点赋值给数组索引位置
             */
            if ((tab[index] = hd) != null)
                /*
                    转成红黑树的具体操作
                 */
                hd.treeify(tab);
        }
    }

说明

size表示HashMap中键值对的实时数量,这个不等于数组的长度
threshold(临界值)= capacity(容量)* loadFactor(负载因子)。这个值是当前已占用数组长度的最大值。size 超过这个值就重新 resize(扩容),扩容后的 HashMap 容量是之前容量的两倍。

JDK1.7中的put方法

public V put(K key, V value) {
        /*
            如果Key是null的话,则调用putForNullKey方法
            putForNullKey:如果不存在null为key的Entry则新增,如果存在的话则替换原来的值并返回
         */
        if (key == null)
            return putForNullKey(value);
        /*
            key.hashCode():调用key的hashCode()获取hashCode
            hash(key.hashCode()):通过调用hash方法获得hash值
            这个操作实际上和JDK1.8的HashMap的hash(key)类似,也是通过该方法使得高低位都参与
            hash计算从而避免hash冲突,大家可以参考一下上面JDK1.8的HashMap
         */
        int hash = hash(key.hashCode());
        /*
            这一步是计算出数组的索引下标
            计算方法和JDK8一样
         */
        int i = indexFor(hash, table.length);
        /*
            Entry<K,V> e = table[i]:将索引下标对应的元素赋值给Entry
            这个步骤实际上就上遍历链表查找元素
         */
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            /*
                e的哈希值和新元素的hash值相等且内容也相同则说明key相同
                用新值替换节点中的旧值并将旧值返回
             */
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 这个变量是用来记录修改次数的
        modCount++;
        // 到这一步说明没有key重复的元素,新增元素
        addEntry(hash, key, value, i);
        return null;
    }



void addEntry(int hash, K key, V value, int bucketIndex) {
        /*
            获取索引位置的Entry
         */
        Entry<K,V> e = table[bucketIndex];
        /*
            采用头插法将元素插入到链表中
            新节点插入后将e赋值给next
         */
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 判断新增元素后数组大小是否超过阈值
        if (size++ >= threshold)
            // 扩容方法,将扩大为原来数组大小的两倍
            resize(2 * table.length);
    }

扩容resize

首先扩容的时机不同
在1.7中进行初始化或内部当size超过阈值时会触发扩容, 扩容之后的数组大小为之前的两倍, 并且之前该下标的元素只会继续保存在该下标或者两倍的下标位置.
在1.8中扩容触发条件有两个
当初始化或size超过阈值时会触发扩容
一条链表上节点数量超过8时会调用treeifyBin()方法, 方法内部如果数组长度小于64则会触发resize()扩容方法

HashMap在进行扩容时,每次扩容后的大小都是原来数组的两倍,然后将原数组中的元素分配到新的数组中去,那么它是如何分配的呢?由于每次进行扩容都是原来大小的两倍,计算table下标的方法是hash&(newTable.length-1),也就是hash&(oldTable.length*2-1),于是我们有了这样的结论:这新旧两次计算下标的结果,要不然就相同,要不然就是新下标等于旧下标加上旧数组的长度
其实hash值的对应的新数组下标是不是需要加上旧数组的长度,只需要看看hash值&旧数组长度(hash&oldTable.length)是不是1就行了如果是1的话就是原数组中的位置+原数组长度,0的话就是原数组中的位置
JDK1.7中的扩容方法

void resize(int newCapacity) {
        // 获取源数组
        Entry[] oldTable = table;
        // 原数组容量大小
        int oldCapacity = oldTable.length;
        // 判断原容量大小是否已经是最大值了
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 新建数组大小为原数组大小的两倍
        Entry[] newTable = new Entry[newCapacity];
        /*
            扩容方法的关键,重新计算索引分配位置
         */
        transfer(newTable);
        // 新数组替换原数组
        table = newTable;
        // 新阈值
        threshold = (int)(newCapacity * loadFactor);
    }

   void transfer(Entry[] newTable) {
        // 源数组
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            // 将元素赋值给e
            Entry<K,V> e = src[j];
            if (e != null) {
                // 将原来位置的元素置为null,方便GC
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    // 重新计算元素在新数组中的位置
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

 static int indexFor(int h, int length) {
        return h & (length-1);
    }

JDK1.8中的扩容方法

final Node<K, V>[] resize() {
        // 源数组
        Node<K, V>[] oldTab = table;
        // 原来的数组容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 原来数组的阈值
        int oldThr = threshold;
        /*
             newCap:新数组的容量,初始值为0
             newThr:新数组的阈值,初始值为0
         */
        int newCap, newThr = 0;
        // 判断原来的数组大小是否不为0
        if (oldCap > 0) {
            /*
                原数组的容量已经大于等于最大容量
                将最大值赋值给原来的阈值并返回原数组
             */
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            /*
                (newCap = oldCap << 1):将原数组左移一位,也就是扩大为原来的2倍并赋值给新容量newCap
                新容量小于最大容量值且原数组容量要大于默认的初始容量16则将阈值扩大
             */
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 阈值扩大一倍
                newThr = oldThr << 1; // double threshold
        }
        /*
            原阈值大于0则赋值给新容量
            这里肯能有疑问为啥将原数组阈值大小赋值给新容量?
            看看前面的JDK1.8中的有参构造方法就明白了,
            在tableSizeFor方法体内部将计算后的数据直接赋值给threshold边界值了
         */
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            /*
                进入else则说明原来数组的容量和阈值都是0,则进行初始化默认值
                newCap:赋值初始值16
                newThr:新阈值=0.75*16=12
             */
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        /*
            新阈值还是初始值0则计算新阈值
         */
        if (newThr == 0) {
            // ft = 新容量*负载因子
            float ft = (float) newCap * loadFactor;
            // 新数组容量不超过最大值且ft小于最大值则取ft为新阈值
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
                    (int) ft : Integer.MAX_VALUE);
        }
        // 将新阈值赋值给成员变量threshold
        threshold = newThr;
        // 创建新长度的数组newTab
        @SuppressWarnings({"rawtypes", "unchecked"})
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        // 将新数组赋值给成员变量table
        table = newTab;
        if (oldTab != null) {
            // 遍历原数组,将数据放到新的数组中去
            for (int j = 0; j < oldCap; ++j) {
                // 用来保存遍历中的元素
                Node<K, V> e;
                if ((e = oldTab[j]) != null) {
                    /*
                        将原数组中索引位置的元素赋值给e后,将索引位置的元素置为null方便GC
                     */
                    oldTab[j] = null;
                    /*
                        判断数组是否有下一个引用,如果e.next为空则说明不是链表,直接将元素放到数组中即可
                     */
                    if (e.next == null)
                        /*
                             将原数组中的原素放到新数组中
                             e.hash & (newCap - 1):这一步是计算元素放到新数组的索引位置
                         */
                        newTab[e.hash & (newCap - 1)] = e;
                    /*
                        判断是否是红黑树
                     */
                    else if (e instanceof TreeNode)
                        // 说明是红黑树来,则调用相关方法处理
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                    else {
                        /*
                            到了else说明是链表
                            loHead:下标不变情况下的链表头
                            loTail:下标不变情况下的链表尾

                            hiHead:下标改变情况下的链表头
                            hiTail:下标改变情况下的链表尾
                         */
                        Node<K, V> loHead = null, loTail = null;
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        do {
                            // 将e的next节点赋值给next变量
                            next = e.next;
                            // 这里来判断如果等于true e这个结点在resize之后不需要移动位置,也就是对应数组下标不变,这里也就是判断是不是新索引位置=原数组长度+原数组位置
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            } else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);// 将next赋值给e,继续循环直到next为空
                        // 原索引放到数组中
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 原索引+oldCap放到数组中
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

一个很重要的区别是,jdk1.7中逻辑,对于所有元素,重新rehash并放到对应的位置,进行头插法
1.8中对于一个hash槽上的链表。遍历table[i]上的链表,如果(e.hash & oldCap) == 0,放入链表中loHead 和loTail 否则放入hiTail和hiHead的链表中 ,lo链表直接位置不变放入新链表中,hi链表当前位置j+oldCap放入新链表中,旧数组的不同槽一定不会重新分到相同的的新槽中,不会冲突,因此可以直接复制

头插与尾插

根据前面的代码可以看出来,1.8采用的尾插法,1.7采用的头插法,我们知道头插法性能是要优于尾插法的,那么jdk为什么要弃用头插,使用尾插法

  1. put元素时为了计算链表长度,判断是否要转为红黑树

JDK1.8 之前使用的是数组+链表,链表就是解决 hash 值冲突的,使用的是头插法。
JDK1.8 后使用的是数组+链表+红黑树,hashmap 的初始容量是 16,加载因子是 0.75,就是 16x0.75=12,就需要扩容,当数组扩容大于 64,且阈值大于 8,链表就会转成红黑树,查询较快,在链表小于阈值 8 时,使用的是尾插法
并且,红黑数的插入新节点,也是作为红节点查到根节点的,也是尾插法
因为当数组扩容大于 64,且阈值大于 8,链表就会转成红黑树,那么实际上尾插法对插入的性能影响时十分小的

  1. rehash时,头插法会打乱节点顺序。容易造成死循环

那么如何产生死循环的,那么看看,回顾resize和transfer方法

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    ...
 
    Entry[] newTable = new Entry[newCapacity];
    ...
    transfer(newTable, rehash);
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
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;
        }
    }
}

创建一个新的newTable,进入transfer方法。

案例分析

假设HashMap初始化大小为4,插入个3节点,不巧的是,这3个节点都hash到同一个位置,如果按照默认的负载因子的话,插入第3个节点就会扩容,为了验证效果,假设负载因子是1.
以上是节点移动的相关逻辑。
在这里插入图片描述

插入第4个节点时,发生rehash,假设现在有两个线程同时进行,线程1和线程2,两个线程都会新建新的数组。
在这里插入图片描述

假设 线程2 在执行到Entry<K,V> next = e.next;之后,cpu时间片用完了,这时变量e指向节点a,变量next指向节点b。
线程1继续执行,很不巧,a、b、c节点rehash之后又是在同一个位置7,开始移动节点
第一步,移动节点a
在这里插入图片描述
第二步,移动节点b
在这里插入图片描述

注意,这里的顺序是反过来的,继续移动节点c
在这里插入图片描述

这个时候 线程1 的时间片用完,内部的table还没有设置成新的newTable, 线程2 开始执行,这时内部的引用关系如下:
在这里插入图片描述

可以发现经过扩容rehash之后会,节点顺序反过来了。
这时,在 线程2 中,变量e指向节点a,变量next指向节点b,开始执行循环体的剩余逻辑。

Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;

执行之后的引用关系如下图
在这里插入图片描述

执行后,变量e指向节点b,因为e不是null,则继续执行循环体,执行后的引用关系

在这里插入图片描述

变量e又重新指回节点a,只能继续执行循环体,这里仔细分析下:
1、执行完Entry<K,V> next = e.next;,目前节点a没有next,所以变量next指向null;
2、e.next = newTable[i]; 其中 newTable[i] 指向节点b,那就是把a的next指向了节点b,这样a和b就相互引用了,形成了一个环;
3、newTable[i] = e 把节点a放到了数组i位置;
4、e = next; 把变量e赋值为null,因为第一步中变量next就是指向null;
所以最终的引用关系是这样的:

在这里插入图片描述

节点a和b互相引用,形成了一个环,当在数组该位置get寻找对应的key时,就发生了死循环。
另外,如果线程2把newTable设置成到内部的table,节点c的数据就丢了,看来还有数据遗失的问题。

总结

所以在并发的情况,发生扩容时,可能会产生循环链表,在执行get的时候,会触发死循环,引起CPU的100%问题,所以一定要避免在并发环境下使用HashMap。

曾经有人把这个问题报给了Sun,不过Sun不认为这是一个bug,因为在HashMap本来就不支持多线程使用,要并发就用ConcurrentHashmap
1.8中在扩容时,采用了的尾插法的,头插法扩容不会改变节点顺序,因此无法成环。注意,采用头插法不会解决扩容的线程安全,仅仅是避免成环,在多线程环境下仍然可能会出现很多无法预料的情况!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/59197.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Mysql进阶学习(八)DDL语言+数据类型和DTL语言

Mysql进阶学习&#xff08;八&#xff09;DDL语言与DTL语言DDL语言1、简介&#xff1a;1.1、库的管理1.1.1、库的创建1.1.2、库的修改1.1.3、库的删除1.2、表的管理1.2.1.表的创建 ★1.2.2.表的修改1.2.3.表的删除1.2.4.表的复制测试案例1. 创建表dept12. 将表departments中的数…

SpringBoot_整合Thymeleaff模板引擎

Thymeleaf模板引擎的主要目标是将优雅的自然模板带到开发工作流程中&#xff0c;并将HTML在浏览器中正确显示&#xff0c;并且可以作为静态原型&#xff0c;让开发团队能更容易地协作。Thymeleaf能够处理HTML&#xff0c;XML&#xff0c;JavaScript&#xff0c;CSS甚至纯文本。…

Qt扫盲-Qt Designer 设计师使用总结

Designer 设计师使用总结一、顶部菜单栏1. 常用的菜单内容2. 快捷工具栏说明二、左侧控件栏1. 组件分类2. 筛选三、中间绘图区1. 左侧控件区拖放控件到中间2. 中间区域布局3. 属性修改四、右侧属性栏1. 对象查看器2. 属性编辑器3.组织结构2. 属性设置五、美化专栏1.单个设置层叠…

微服务框架 SpringCloud微服务架构 12 DockerCompose 12.2 部署微服务集群

微服务框架 【SpringCloudRabbitMQDockerRedis搜索分布式&#xff0c;系统详解springcloud微服务技术栈课程|黑马程序员Java微服务】 SpringCloud微服务架构 文章目录微服务框架SpringCloud微服务架构12 DockerCompose12.2 部署微服务集群12.2.1 直接开干12 DockerCompose 1…

大数据:Hive简介及核心概念

一、简介 Hive 是一个构建在 Hadoop 之上的数据仓库&#xff0c;它可以将结构化的数据文件映射成表&#xff0c;并提供类 SQL 查询功能&#xff0c;用于查询的 SQL 语句会被转化为 MapReduce 作业&#xff0c;然后提交到 Hadoop 上运行。 特点&#xff1a; 简单、容易上手 (…

做短视频不知道靠什么变现,分享三个自我商业定位的方法,适用普通人

如果说你还停留在我也不知道我可以靠什么赚钱这样的一个状态当中。那我给你三个自我商业定位的方法。篇幅较长&#xff0c;点赞收藏慢慢看哦 首先第一个方法&#xff0c;从工作上或者专业的事情上找变现的方法。 那么你们需要了解一个概念叫做知识的诅咒。什么意思呢&#xf…

【论文整理1】On the Continuity of Rotation Representations in Neural Networks

1.前置知识 1.1 Gram-Schmidt正交化 【参考阅读】Gram-Schmidt过程 看完这篇应该基本能理解&#xff0c;但是他对于公式的讲解有一个地方讲解得不是很清楚! 即为什么分母是平方形式呢&#xff1f; 1.2 差集 定义&#xff1a;差集是一种集合运算&#xff0c;记A&#xff0…

Java并发编程—CompletableFuture的介绍和使用

在博主上一篇博客介绍中&#xff0c;Java并发编程—java异步Future的迭代过程_小魏快起床的博客-CSDN博客&#xff0c;这里面给大家分析了Future的使用过程和一些存在的问题&#xff0c;那么针对里面出现的阻塞问题&#xff0c;博主将在这一篇文章给大家介绍清楚 &#x1f34f…

MyBatis框架简介

MyBatis是一个开源的数据持久层框架&#xff0c;内部封装了通过JDBC访问数据库的操作&#xff0c;支持普通的SQL查询、存储过程和高级映射。作为持久层框架&#xff0c;主要思想是将程序中的大量的SQL语句分离出来&#xff0c;配置在相应的配置文件中&#xff0c;这样可以在不修…

Java—数据类型

文章目录数据类型八大基本数据类型Java中有了基本数据类型&#xff0c;为什么还要包装类型String字符串类型函数字符串类的length()方式是否能够得到字符串内有多少个字符&#xff1f;不可变字符串String为什么要设计成不可变的&#xff1f;boolean类型占多少位&#xff1f;为什…

【springboot进阶】使用aop + 注解方式,简单实现spring cache功能

目录 一、实现思路 二、定义缓存注解 三、aop 切面处理 四、使用方式 五、灵活的运用 六、总结 前几天有同学看了 SpringBoot整合RedisTemplate配置多个redis库 这篇文章&#xff0c;提问spring cache 能不能也动态配置多个redis库。介于笔者没怎么接触过&#xff0c;所以…

【Java开发】 Spring 08 :访问 Web 资源( 借助 RestTemplate or WebClient )

web 资源就是运行在服务器上的资源&#xff0c;比如放到 web 下的页面 js 文件、图片、css等&#xff0c;web资源分为静态web资源和动态web资源两类&#xff0c;接下来访问的就是动态资源&#xff08;页面返回的数据是动态的&#xff0c;由后端程序产生&#xff09;&#xff0…

Android 使用元数据

Android 使用元数据 前提介绍Metadata 有时候为安全起见&#xff0c;某个参数要给某个活动专用&#xff0c;并不希望其他活动也能获取该参数&#xff0c;也就是要使用第三方SDK时。Activity提供了元数据&#xff08;Metadata&#xff09;的概念&#xff0c;元数据是一种描述其…

C++类和对象(二)构造函数、析构函数、拷贝构造函数

目录 1.类的6个默认成员函数 2. 构造函数 2.1 概念 2.2 特性 3.析构函数 3.1 概念 3.2 特性 4. 拷贝构造函数 4.1 概念 4.2 特征 1.类的6个默认成员函数 如果一个类中什么成员都没有&#xff0c;简称为空类。 空类中真的什么都没有吗&#xff1f;并不是&#xff0c;…

【菜菜的sklearn课堂笔记】聚类算法Kmeans-聚类算法的模型评估指标

视频作者&#xff1a;菜菜TsaiTsai 链接&#xff1a;【技术干货】菜菜的机器学习sklearn【全85集】Python进阶_哔哩哔哩_bilibili 可以只看轮廓系数和卡林斯基-哈拉巴斯指数 不同于分类模型和回归&#xff0c;聚类算法的模型评估不是一件简单的事。在分类中&#xff0c;有直接结…

【尚硅谷】Java数据结构与算法笔记02 - 队列

文章目录一、使用场景二、队列介绍三、数组模拟队列3.1 思路分析3.2 Java代码实现3.3 问题分析与优化四、数组模拟环形队列4.1 思路分析4.2 Java代码实现一、使用场景 银行排队&#xff0c;先到先得测核酸&#xff0c;先到先测 二、队列介绍 队列是一个有序列表, 可以用数组…

硬盘压缩将C盘拓展成D盘和E盘

硬盘压缩将C盘拓展成D盘和E盘1. 现状2. 硬盘压缩2.1 进入计算机管理2.2 磁盘管理压缩卷3. 分配新盘符3.1 查看盘符是否被占用3.2 新建D盘刚安装好系统的电脑有可能只有一个C盘&#xff0c;我们工作学习的时候远远不够&#xff0c;那怎么拓展其他盘符呢&#xff1f; 接下来让我们…

PyQt5基础练习1

0. 本文学习地址 1. PyQt5是由一系列Python模块组成 超过620个类&#xff0c;6000函数和方法。能在诸如Unix、Windows和Mac OS等主流操作系统上运行。 1.1 PyQt5有两种证书 GPL商业证书 2. 实验1 实现简单的窗体 2.1 完整代码 #!/usr/bin/python3 # -*- coding: utf-8 -*…

专业尖端远心光学,高精度视觉检测解决者

随着机器视觉系统在精密检测领域的广泛应用&#xff0c;在精密光学测量系统中&#xff0c;由于普通光学镜头会存在一定的制约因素&#xff0c;如影像的变形、视角选择而造成的误差、不适当光源干扰下造成边界的不确定性等问题&#xff0c;进而影响测量的精度。为弥补普通镜头应…

155. RESTframe的请求和响应

1.请求和响应 REST framework引入了2个新的对象&#xff1a;Request和Response 1.1 Request 包结构&#xff1a;rest_framework.request.Request 该对象扩展了常规的HttpRequest &#xff0c;增加了对REST框架灵活的请求解析和请求认证的支持 主要属性&#xff1a; data 这个…