HashMap源码分析

参考资料：

谢谢这些大佬(⊙o⊙)

https://blog.csdn.net/lw_zj_ywn/article/details/78282905

https://blog.csdn.net/qq_33245923/article/details/75195113

https://blog.csdn.net/qq_31865983/article/details/85029182

https://blog.csdn.net/q3244676719/article/details/81540830

 

---

目录

1.hashmap是什么？

2.hashmap 原理分析    

3.总结一下

4.hashmap并发问题

---

 

 1.hashmap是什么？

     hashmap内部综合数组和链表两种基础的数据结构。（在JDK1.8之后，hashmap会在链表长度达到8及其以上时，将链表转化为红黑树。）

     数组：有序的元素序列，需要一段连续的内存区域。寻址简单，插入困难，删除困难。

     链表：内存占用松散，每个元素之间的关联依靠前一个元素的指针。寻址困难（查找时无法使用适用于数组的各种查找方法），插入简单，删除简单。

     红黑树：平衡二叉树的一种，详细参考https://blog.csdn.net/q3244676719/article/details/81540830

     综合数组和链表的优点，hashmap在没有发生hash冲突的情况下，它的删除，插入，查找的时间复杂度均为O(1)。

     hashmap：既没有占用过多的连续空间，除此之外还有用比较高的寻址效率。

     在数据较少情况下的hashmap采用”拉链法“，图示如下：

                                           

       可以较为清楚地看到，hashmap的基本结构就是一个存entry对象（之后会详细介绍）的数组，然后每一个entry对象有三个值得注意的内部参数：key，value，next。

       key，value：存入时候的键值对，key值还用作hash值的计算。

       next：指向链表下一项的指针。

       

2.hashmap 原理分析    

       笔者从hashmap的使用过程开始，一步一步的将自己对源码的理解表示出来。

       一个放弃思考的例子：          

        HashMap map=new HashMap();

        map.put("a", "asdasd");

        map.get("a");

       1.首先，我们点进HashMap的初始化方法

  

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
        //这里初始化了一个变量，这个变量叫做”负载因子“
        //默认值为0.75
    }

      那么负载因子是什么？

      可以很明显的看到，我初始化这个hashmap时，并没有指定大小，类似于ArrayList的自动扩容实现（虽然它并没有什么负载因子倒是了），这个负载因子表示的是，在数据加载到何种程度时，对hashmap进行扩容。扩容代码的讲解会放在后面。

      我们回过头来看看其他的构造函数：

 

public HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity)
public HashMap(Map<? extends K, ? extends V> m)

      第三个构造函数暂时不看。

      第一个构造函数中传入了一个loadFactor，这个就是自定义负载因子。而第一个和第二个构造函数的第一个参数我们点进代码里看看：

     

//调用另一个构造函数，传入默认负载因子
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }


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);
        
        //上面的代码是在检测参数的合法性，没啥好说的
        //这里赋值加载因子
        this.loadFactor = loadFactor;
        //出现了一个新玩具：threshold
        this.threshold = tableSizeFor(initialCapacity);
    }

      第一个参数没有进行比较明确的赋值，所以我们点进tableSizeFor方法进去看看。（其实我没看懂，然后从其他博客中了解到一下内容）

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;
    }

    这里的逻辑得到的结果是：将大于传入初始容量的2的幂返回，（比如如果传入的大小是10，那么返回的是2的四次幂16，传入3，那么返回的是2的两次幂4）。这个算法的具体逻辑有一篇文章分析得很好，https://blog.csdn.net/fan2012huan/article/details/51097331 。

    那么构造函数大致内容到此为止。构造函数中我们初始化了一个loadFactor的变量，初始化了threshold变量，后者用来表示扩容的阈值，他们具体的作用在这里还没有显现出来，先记着。   

    那么看到put方法

public V put(K key, V value) {
        //这里调用的了另一个函数
        //并传入了key计算出的hash值
        return putVal(hash(key), key, value, false, true);
    }

//先不着急打开putVal方法，先看看hash()的内部结构

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

      每一个类都继承自Object，Object对象中有一个方法hashCode()可以获得对象的hashCode（好像这一段说不说都没意义= =）。值得注意的是这里并没有直接使用Object对象的hashCode()，而是将原本的hashCode先无符号向右移动十六位，然后与原本的hashCode异或，这里还不太明白为啥要这么做。继续往后。

      直接看接下来的代码是非常艹蛋的，那么我先说一下里面一些变量的意义。

      table:hashmap的entry数组。

      Node:这是实现了entry接口的对象，- -table里面存的entry其实都是这里的Node对象。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判定是否需要重新计算大小，但是length是啥 代码里是没有的
        //只能猜它代表了table的长度
        if ((tab = table) == null || (n = tab.length) == 0)
            //resize函数重新计算一下长度
            n = (tab = resize()).length;

        //这里算一下插入元素的预计位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            //如果位置是空，那么直接插入
            tab[i] = newNode(hash, key, value, null);
        else {
            //不为空，那么进行冲突处理
            Node<K,V> e; K k;
            //判定插入项是否已经存在了（hash值是否相等，key值是否相等）
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果存在，那么直接赋值
                e = p;

            //如果节点为TreeNode，那么调用另一个插入函数
            //当单个链表的长度大于8，那么链表将会转化为红黑树
            //这里就是插入转化为红黑树的节点
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

            else {
                //下面就是插入没有变成红黑树的节点
                for (int binCount = 0; ; ++binCount) {
                    /*注意这里e的赋值*/
                    if ((e = p.next) == null) {
                        //直到找到链表的尾部，然后新建一个节点
                        //其实p的next节点就是e
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            //如果插入之后链表长度达到了8，那么调用下面这个函数
                            //将链表转化为树
                            treeifyBin(tab, hash);
                        break;
                    }
                    //e指向的节点是我们要覆盖的节点，那么直接退出循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //这里相当于将p往后移动一个
                    p = e;
                }
            }
            //最后我们得到了e，这个e是我们要插入的节点，但是还没有具体的赋值
    
            
            if (e != null) { // existing mapping for key
                //拿出e之前的值
                //如果e是新建的节点，那么会直接返回新的值
                V oldValue = e.value;
                //onlyIfAbsent表示不更新已经存在的值
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //这方法里啥都没有 = =
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //如果大小超过阈值那么调整
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);//空方法
        return null;
    }

     从结果上看，put方法会返回一下几种情况：

     1.存在相同节点，返回节点以前的value

     2.不存在节点，返回新建节点value

     3.不存在节点，而且table之前没有这个对应此hash值的项，返回null

     展开看看resize函数

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;
            }
            //如果还能扩大，那么新table的长度变为之前的两倍
            //并将新阈值变为之前阈值的两倍
            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 threshold
            //如果之前的阈值大于0，那么新的长度直接等于之前的阈值
            newCap = oldThr;
        else {               
            //如果阈值也小于0
            //那么长度为默认长度，阈值设置为默认阈值
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }

....

     然后单独对newThr进行赋值，也就是对新的阈值进行赋值，从前面的逻辑可以看出，这一段阈值赋值是针对于”之前table长度小于等于0，但是之前的阈值不为0”的情况。

...
if (newThr == 0) {
            //先计算出一个预期的阈值
            float ft = (float)newCap * loadFactor;
            //如果新的长度与预期阈值小于最大值，那么将阈值赋予新的阈值
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
}
//最后经过上面这些折腾，最后将新的阈值赋与threshold
threshold = newThr;
...

     然后使用新计算出的大小（newcap）新建一个hash桶组

@SuppressWarnings({"rawtypes","unchecked"})
            //新建一个hash桶组
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //将之前的hash桶组中的节点添加至新的数组中
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        //这里相当于hash值和最大长度取余
                        //这是在对应桶位只有一个元素的情况
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        //加入一个树节点
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //新建链表
                        //这里对应扩容之前的链表部分
                        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;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                //放在新的位置
                                //（hiTail表示的就是扩容之后的新部分）
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            //放在桶组的旧位置（loTail对应的链表就是不需要改变的部分）
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            //放在桶组的新位置
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }

        return newTab;

    然后展开split方法看看

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 order
            //同理，一个新的树节点（存储新位置的节点），一个旧的树节点（存储节点位置没变的位置）
            TreeNode<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;
                //位置没有发生改变的节点，放在lo
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                //位置发生改变的节点（或者说，正是因为有这些不能放在之前位置的节点，才需要对容器 
                //进行扩容）
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                //如果最长长度小于6，那么解除链表的树化
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            //以下同理，只是插入原数组的位置发生了改变
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }

 

     最后，看看树化与解除树化的代码。

     

final void treeify(Node<K,V>[] tab) {
            //新建一个根节点
            TreeNode<K,V> root = null;
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (root == null) {
                    //如果根节点还为空，那么直接让x变为根节点
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    //在根节点存在情况下
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = root;;) {
                        //dir判断节点的左右，ph记录当前节点的hash值
                        int dir, ph;
                        K pk = p.key;
                        //与根节点的hash值进行比较（！！用hash值判断节点的左右）
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);//?不懂
                        
                        TreeNode<K,V> xp = p;
                        //判断插入的方向，并将p向后移动，如果找到符合位置的空节点
                        //那么插入，退出循环
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            //调整红黑树平衡
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root);
        }

      打开红黑树的平衡代码

      首先红黑树的插入有以下规则:

1. 节点是红色或黑色
2. 根节点一定是黑色
3. 每个叶节点都是黑色的空节点
4. 每个红节点的两个子节点都是黑色的(从每个叶子到跟的所有路径上不能有两个连续的红节点)(即对于层来说除了NIL节点，红黑节点是交替的，第一层是黑节点那么其下一层肯定都是红节点，反之一样)
5. 从任一节点到其每个叶子节点的所有路径都包含相同数目的黑色节点

     (新插入的节点一定是红色，因为红色节点打乱规则5的几率最小)

     这个节点是对红黑树进行平衡修正，不是插入哦！！插入已经在上一个方法做过了(光从代码看逻辑很扯，建议在看之前好好了解一下红黑树的原理)

static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                    TreeNode<K,V> x) {
            //插入节点都是红色（之后可能会改变，但是一开始都是红色）
            x.red = true;
            //xp:插入节点的爸爸
            //xpp:插入节点的爷爷
            //xppl:爷爷的左孩子
            //xppr:爷爷的右孩子
            for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
                //如果他没有父节点，说明他现在所处的位置一定是根节点
                //那么将它置为黑色，返回
                if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
                else if (!xp.red || (xpp = xp.parent) == null)
                    //如果父节点为黑色，那么插入一个红色节点不会影响红黑树结构
                    //或者说，如果他的父节点就是根节点（parent为空），那么也直接插入，不影响
                    return root;

                //如果父亲节点是爷爷节点的左孩子
                if (xp == (xppl = xpp.left)) {
                    if ((xppr = xpp.right) != null && xppr.red) {
                        //叔叔（爷爷的右孩子）节点不为空，而且是红色
                        xppr.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    else {
                        //叔叔为空，或者叔叔存在
                        if (x == xp.right) {
                            //左旋
                            root = rotateLeft(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;//将父节点设置为黑色
                            if (xpp != null) {
                                //爷爷节点设置为红色
                                xpp.red = true;
                                //右旋
                                root = rotateRight(root, xpp);
                            }
                        }
                    }
                }
                else {
                    //同理
                    if (xppl != null && xppl.red) {
                        xppl.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    else {
                        if (x == xp.left) {
                            root = rotateRight(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateLeft(root, xpp);
                            }
                        }
                    }
                }
            }
        }

 

      解除树化代码

final Node<K,V> untreeify(HashMap<K,V> map) {
            Node<K,V> hd = null, tl = null;
            for (Node<K,V> q = this; q != null; q = q.next) {
                //转化节点种类
                Node<K,V> p = map.replacementNode(q, null);
                //hd链表头部
                if (tl == null)
                    hd = p;
                else
                    tl.next = p;
                //tl表示链表尾部
                tl = p;
            }
            return hd;
        }

 

3.总结一下

 

1. hashmap是链表和数组两种数据结构的综合，折中了两者的优点
2. hashmap扩容，在不超过最大容量的情况下，将原容量翻倍（✖️2），但是这是针对于第一层桶数组。
3. 对于第二层链表，在长度大于8的情况下会转化为红黑树，在长度小于6的情况下，会转化为链表

 

4.hashmap并发问题

 

     很明显，我们的hashmap并没有使用synchronize或是lock对写操作和读操作进行处理，那么会出现什么问题呢？

     我们回到resize函数中，这次我单独拿出新建链表的逻辑。（读写并发问题没什么好说的，这里解释一下扩容过程的问题）

                       do {
                            next = e.next;
                            //判断是否放在之前的位置
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                //放在新的位置
                                //（hiTail表示的就是扩容之后的新部分）
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);

      这里将链表正序拷贝到新的桶组当中。那么我们假设一个情景，这时候有A，B两个线程。并假设hashmap的hash方法就是简单的%length。

     假如说原始hashmap长这样。（其实早就该开始扩容了，但是没关系，小问题）

                                             

然后A线程开始扩容(翻倍，扩容为4)，正当A进程开始了一段时间后

此时A在resize函数中的各个参数值如下(key=2那一行暂时不看)：

       A刚算到,(key=1)的扩容，loHead=(key=1)，e指着(key=3),（假设刚好执行完了一次循环next还没被赋值成(key=5)）这时候的A中的新桶组大概可以看成这样。

                                         

 

       在这个时候，A线程时间片用完了，暂停下来了，（用时间片的说法只是为了方便解析，毕竟能停一会）。B线程拿到时间片，进行resize方法，假设它成功的执行完了resize。那么现在的桶组就会是这样的情况。

                                

       然后回到A线程，这个时候的A线程继续执行resize，从(key=3)开始，那么没问题，(key=3)成功被插入到新链表里（新位置的链表，详情见resize，这里就是桶组里的第三个位置），这时候我们参照在B线程中成功resize的桶组，(key=3)的next指针为空，什么意思呢？说明在这次扩容的过程中，我们无法在得到(key=5)，本来要使用(key=3)的next指针得到(key=5)，但是这时候已经无法得到了，那么自然，方法会自动判定，它觉得自己已经完成了扩容，然后将下图写入内存，最后(key=5)就不见了。