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)