HashMap 源码分析

简介

JDK1.7:

1.数据结构是数组加链表
2.在并发的情况,发生扩容时,可能会产生循环链表,在执行get的时候,会触发死循环,引起CPU的100%问题
3.在并发的情况会产生数据丢失

JDK1.8

1.数据结构是数组加链表、红黑树
2.在并发的情况会产生数据丢失

数据结构

hashMap1.png
Hash散列结构

用于将 key 的 hashCode 映射为数组上的角标

// 拿到key的hash值后与其无符号右移16位取与
// 通过这种方式,让高位数据与低位数据进行异或,以此加大低位信息的随机性,变相的让高位数据参与到计算中。
 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
// 获取到处理后的Hash值后计算数组中的位置
// n 为数组的长度即 length,index 为数组中的位置
index = hash % n

//和上面的算法相同,但效率高
index = (n - 1) & hash 

为什么 hash 对 length 取余就能得到数组角标?
因为 hash 对数组的长度取余,那么得到的数一定在数组长度范围之内

所以 index 和数组长度有关
这也是为什么当数组长度变化后,所有的元素都要重新计算位置。

数组结构:

存储链表或红黑树的首个节点

单向链表结构:
static class Node implements Map.Entry {
    final int hash;
    final K key;
    V value;
    Node next;
    //构造函数
    Node(int hash, K key, V value, Node next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    // getter and setter ... toString ...
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry e = (Map.Entry)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

红黑树结构:

LinkedHashMap.Entry 继承自 HashMap.Node ,所以 TreeNode 继承自 上面链表结构的 Node

static final class TreeNode extends LinkedHashMap.Entry {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node next) {
        super(hash, key, val, next);
    }

    /**
     * Returns root of tree containing this node.
     */
    final TreeNode root() {
        for (TreeNode r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }

源码分析

变量说明

注意:这里的容量指的是数组的容量也是HashMap的容量,而 size 字段则代表HashMap当前存储的数据量,即HashMap中键值对的数量

/**
 * 默认初始容量16(必须是2的幂次方)
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

/**
 * 最大容量,2的30次方
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默认加载因子,用来计算threshold
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 链表转成树的阈值,当桶中链表长度大于等于8时转成树 
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 进行resize操作时,若桶中数量小于等于6则从树转成链表
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 桶中结构转化为红黑树对应的table的最小大小

 当需要将解决 hash 冲突的链表转变为红黑树时,
 需要判断下此时数组容量,
 若是由于数组容量太小(小于 MIN_TREEIFY_CAPACITY )
 导致的 hash 冲突太多,则不进行链表转变为红黑树操作,
 转为利用 resize() 函数对 hashMap 扩容
 */
static final int MIN_TREEIFY_CAPACITY = 64;
/**
 保存Node节点的数组
 该表在首次使用时初始化,并根据需要调整大小。 分配时,
 长度始终是2的幂。
 */
transient Node[] table;

/**
 * 存放具体元素的集
 */
transient Set> entrySet;

/**
 * 记录 hashMap 当前存储的元素的数量
 */
transient int size;

/**
 * 每次更改map结构的计数器
 */
transient int modCount;

/**
 * 用于判断是否需要扩容
 * threshold = capacity * loadFactor
 * 
 * 如果 size > threshold 则进行扩容
 * 这里的size是指HashMap 的size不是数组的长度
 *
 */
int threshold;

/**
 * 加载因子:用于计算threshold
 */
final float loadFactor;

HashMap 添加元素:
hashMap2.png
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i;

        //判断数组是否为空,如果为空则重新初始化数组
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //判断当前 hash 计算后数组位置上的元素是否为空
        if ((p = tab[i = (n - 1) & hash]) == null)
            //当前位置没有元素这直接将 Node 放入即可
            tab[i] = newNode(hash, key, value, null);
        else {
            //该位置已经有元素了,解决hash碰撞

            Node e; K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                //当前传入的key 和 当前位置上的key 是同一个,说明只要修改值就行了
                e = p;
            else if (p instanceof TreeNode)
                //当前传入的key 和 当前位置上的key 不是同一个,且当前节点为红黑树节点,将传入的元素加入红黑树
                e = ((HashMap.TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
                //当前传入的key 和 当前位置上的key 不是同一个,且当前节点不是红黑树,那就是链表结构
                //遍历链表,插入传入的元素
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 如果p的next为空,将传入的元素添加到链表后面
                        p.next = newNode(hash, key, value, null);
                        //如果链表长度大于等于8 则转化为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //判断传入的元素已经添加到链表最后一个节点,中断循环
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                //根据规则选择是否覆盖value
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // size自增后大于扩容阈值,进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

首先根据key的哈希值计算出 Node 应该存放在数组什么位置
但是可能会出现哈希冲突,所以当两个不同的key
其哈希是一样的,那么他们存放在数组中的位置就是相同的,这时候会将这两个Node用链表的结构存放,但是当数组中一个位置的链表元素大于等于8个时,链表插入的效率贬低,此时链表结构会转换为红黑树

[图片上传失败...(image-c2ec54-1664265469619)]

扩容机制

添加元素时,如果 size > threshold 则进行扩容,size 为HashMap当前存储的数据量,

  final Node[] resize() {
        Node[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;//默认值为0,如果在HashMap构造函数中传入了数组的容量,会给 threshold 赋值
        int newCap, newThr = 0;
        
        /* ① 根据原先数组的容量和阈值计算新的容量和阈值 **/
        if (oldCap > 0) {//数组容量大于0 
            if (oldCap >= MAXIMUM_CAPACITY) {//数组容量大于等于最大值,不进行扩容了
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //扩容一倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //如果扩容后小于最大值 而且 旧数组桶大于初始容量16, 阈值左移1(扩大为原有的2倍)   
                newThr = oldThr << 1; // double threshold
        }
        // 下面情况是数组容量小于等于0,说明数组还未被初始化
        
        else if (oldThr > 0) // HashMap构造函数中传入了指定容量,使用指定容量初始化数组
            newCap = oldThr;
        else {               // oldThr小于等于0,数组使用默认容量初始化数组
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        
        /* ② 创建新的数组,更新 threshold 和 数组 **/
        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[] newTab = (Node[])new Node[newCap];
        table = newTab;
        
        /* ③ 遍历原数组,将数据添加到新数组中 **/
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null) // 该节点无其他关联节点直接赋值到新数组
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode) // 如果为树节点,切割树节点,这时如果树的大小小于等于6就会被转成链表
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node next;
                        do {
                            next = e.next;
                            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);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
① 计算扩容后的容量和阈值
  1. HashMap已经初始化(数组容量大于0)

    table的容量以及threshold量扩大为原有的两倍。
    newCap = oldCap * 2
    newThr = oldThr * 2
    
  2. 指定容量的构造方法初始化HashMap(oldThr > 0)

    //指定容量和加载因子构造函数
    public HashMap(int initialCapacity, float loadFactor) {
        ... ...
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
    //取容量最接近2的次幂 的值,为阈值    
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
    
    newCap = threshold
    newThr = newCap * loadFactor
    
  3. 默认构造方法初始化HashMap(oldThr = 0)

    newCap = DEFAULT_INITIAL_CAPACITY = 16
    newThr = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12
    
② 创建新数组

Node[] newTab = (Node[])new Node[newCap];

② 迁移数据至数组
  1. 节点无子节点
    直接重新计算该节点的index
    newTab[e.hash & (newCap - 1)] = e;
    
  2. 节点为链表
    因为HashMap的容量为2的倍数,扩容后也是扩容一倍,所以不用重新计算index,
    只需要判断 x = (e.hash & oldCap)
    
    x == 0 :说明 e 节点的hash值小于 oldCap,那么这些节点的 newIndex = oldIndex。
    
    x != 0 :说明 e 节点的hash值大于等于 oldCap,那么这些节点的 newIndex = (oldIndex + oldCap)
    
  3. 节点为红黑树
    和链表迁移方式相同,多了一步判断红黑树大小如果小于等于6的话会转换为链表结构
    

扩展

HashMap的大小为什么必须是2的倍数?

1.计算数组index时,2的倍数会减少Hash冲突
# index 的算法,n 表示 HashMap 的容量

index = (n - 1) & hash 
n 为2的倍数
进制 n = 8 (n-1) = 7 hash = 10
二进制 0000 1000 0000 0111 0000 1010
# 计算hash为 10,11,12 的index

(n-1) & 10 = 0000 0010 = 2
(n-1) & 11 = 0000 0011 = 3
(n-1) & 12 = 0000 0100 = 4
n 不为2的倍数
进制 n = 9 (n-1) = 8 hash = 10
二进制 0000 1001 0000 1000 0000 1010
# 计算hash为 10,11,12 的index

(n-1) & 10 = 0000 1000 = 8
(n-1) & 11 = 0000 1000 = 8
(n-1) & 12 = 0000 1000 = 8

这里可以看出,n 如果是2的倍数,n-1 则会将后置位的0全部变为1,如果 n 不为2的倍数,则 n-1 的后置位可能存在0,那么无论 hash 值的二进制位为 1 还是 0,&计算后的结果都为0,所以会增加hash冲突

2.每次扩容都是扩容一倍,所以扩容后的大小也是2的倍数,将已经产生hash碰撞的元素转移到新的table中时不用去重新计算index

假设:

oldCap = 8 oldCap-1 newCap == 16 newCap-1
0000 1000 0000 0111 0001 0000 0000 1111
如果: hash < oldCap ,那么hash值的低位第4位一定为0
所以:hash & (oldCap-1) == hash & (newCap-1)
即:newIndex = oldIndex

如果: hash >= oldCap ,那么hash值的低位第4位一定为1
所以:(hash & (oldCap-1)) + oldCap == hash & (newCap-1)
即:newIndex = (oldIndex + oldCap)

你可能感兴趣的:(HashMap 源码分析)