HashMap.put()方法源码解析

HashMap.put()流程：
首先说明，HashMap通过数组+链表/红黑树管理
1.计算需要插入的元素的hash值。
2.第一次插入的话，hash数组默认是空，调用resize()方法，开辟一个长度为默认值的entry数组table，entry指的是包含了哈希值，key，value和后继地址的类，一个entry对象对应一个元素对。开始我不理解我什么要记录每个元素对的key的hash值，阅读源码得知，可能会发生哈希冲突，即两个哈希值不同的元素放到一个链表/红黑树里面。另外扩容的时候需要根据哈希值重新分配table位置。很多博客作图表现出了table中只存储头节点，不存储具体数据。这是错误的。jdk1.8中，源码明显说明table是存储元素数据的。
3.待插入元素的哈希值和（数组长度-1）&运算，显然结果小于等于（数组长度-1），即确定了插入数组的位置。
4.找到位置后，进行插入。这个位置上是一个链表/红黑树。红黑树太复杂了，我现在只考虑链表情况。从表头遍历到表尾，如果发现某个节点和待插入节点的key的哈希值相等，并且equals之下相等，那么用新value覆盖旧的value，找不到的话插到末尾。如果这个时候链表长度大于阈值，将其变为红黑树。
5**.看hashmap中的总分节点个数是否大于阈值**，是的话调用resize()方法扩容。这个非常关键，很多博客写的是错的。
看源码

插入部分

重要的成员变量

transient Node<K,V>[] table;   //存储链表/红黑树的头
transient int size;    //hashmap中的元素总个数

记录键值对的数据结构

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        }

计算哈希值的方法

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

put方法底层是putVal()方法

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

重点分析putVal方法

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab;  //临时表，赋值为table
        Node<K,V> p;    //临时节点  
        int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)  //table为空，显然是第一次插入
            n = (tab = resize()).length;     //resize()方法开辟空间，首地址返回给tab
        if ((p = tab[i = (n - 1) & hash]) == null)      //根据哈希值计算插入元素在table中的位置，如果是空，说明这个位置没有被占用过，直接放入
            tab[i] = newNode(hash, key, value, null);   //在table中的这个位置放入元素，注意，这里说明table存储的不是头指针，是数据
        else {
            Node<K,V> e; K k;     //这个e表示的是待覆盖的节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))    //说明table某个位置上的元素和待插入元素的key的哈希值相同，而且equals（）方法也成立，应该用新value覆盖旧的value
                e = p;      //记录这个位置，待覆盖
            else if (p instanceof TreeNode)     //判断是不是红黑树，红黑树太复杂了，看不懂
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {          //这个是链表情况
                for (int binCount = 0; ; ++binCount) {     //binCount记录链表长度
                    if ((e = p.next) == null) {        
                        p.next = newNode(hash, key, value, null);     //到表尾了，一路没有发现应该覆盖的节点，将新节点插在表尾
                        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;       //说明链表某个位置上的元素和待插入元素的key的哈希值相同，而且equals（）方法也成立，应该用新value覆盖旧的value
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;     //覆盖
            }
        }
        ++modCount;
        if (++size > threshold)     //扩容操作，可见只看元素的总个数
            resize();
        afterNodeInsertion(evict);
        return null;
    }

可以看出，两次扩容操作调用没有区别，但是一次是开辟空间，另一次是空间乘2，怎么回事呢？

resize()源码分析

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;     //扩容之前的table
        int oldCap = (oldTab == null) ? 0 : oldTab.length;    //如果没有初始化，原有的表容量是0
        int oldThr = threshold;        //原有的扩容阈值，初始化前是0
        int newCap, newThr = 0;     //新容量和新阈值
        if (oldCap > 0) {           //已经初始化了的情况
            if (oldCap >= MAXIMUM_CAPACITY) {    //超过了int最大值，自生自灭吧
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            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  
            newCap = oldThr;
        else {               // 这个是初始化情况
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;          //threshold 是记录容量的全局变量
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];   //开辟entry数组，大小为新容量
        table = newTab;      //给全局变量table赋值
        if (oldTab != null) {      //这个是判断是否初始化了
            for (int j = 0; j < oldCap; ++j) {     //遍历原table
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {       
                    oldTab[j] = null;
                    if (e.next == null)   //说明这个是普通节点，直接复制过去
                        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;    //往下我看不懂了，有大神说是nb的位运算，但是整个过程可以看出来尾插法
                        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 {
                                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;
    }

jdk1.8以前的多线程不安全：

简单地说，就是由于头插法引起的。
比如table中某位置有元素entry1->entry2.扩容后需要放入新的位置。线程1记录的是entry1->entry2,但是线程2采用头插法，会将原来的链表逆序。这可能产生循环链表。而操作默认是无环的，就会出现死循环。