HashMap源码剖析

为什么capacity必须是2的整数次幂？

1. 计算key的位置的源码是tab[(n - 1) & hash]，n是tab的length即 capacity，使capacity - 1再与hash进行与运算，就相当对计算结算进行取模，这样提升了计算效率；
2. 保证capacity为偶数，使得 1 中所讲的取模操作不会因capacity - 1出现二进制位有0的情况，使得出现类似 hashcode & 1111110 = xxxxxx0，让底层数组出现部分索引对应的值全为空的情况，提高了数组利用率。

为什么hash(key)中要 h ^ (h >>> 16)？

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

由于绝大多数情况下capacity都小于2^16即小于65536，这样做可以让capacity教小的时候，让key hash的高低位都参与到hash运算，使hash低位值更加随机，能更平均的分布在数组中，同时位运算不会有太大的开销。

put时发生了什么？

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

调用putVal：

finalV putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
    	//resize()作用是初始化table或者将table扩大一倍，此处是初始化。
        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;
        //key的hash相同，不需要关注存储格式，直接获取数组的值，在后续覆盖。
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //生成红黑树格式的结点，在此处插入，调用了putTreeVal()。
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //生成链表格式的结点，如果key都不同则在链尾插入，在此处直接插入；如果有重复的key，在后续覆盖。
        else {
            for (int binCount = 0; ; ++binCount) {
            	//链表尾插入
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //如果长度超过8（默认），将链表转换为红黑树。（0开始的，所以要减一）
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //相同key就绪
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //双指针，p是工具人
                p = e;
            }
        }
        //e就是要覆盖的点,此处只可能是链表
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //是个空方法，这是给LinkedHashMap类服务的，LinkedHashMap是HashMap的子类，是有序哈希表。
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //modecount作用见下一条
    ++modCount;
    //超过阈值，扩容
    if (++size > threshold)
        resize();
    //是个空方法，为LinkedHashMap类服务。
    afterNodeInsertion(evict);
    return null;
}

关于modcount

modCount：记录当前集合被修改的次数，即添加、删除（删除也是+1），这两个操作都会影响元素的个数。

当我们使用迭代器或foreach遍历时，如果你在foreach遍历时，自动调用迭代器的迭代方法，此时在遍历过程中调用了集合的add,remove方法时，modCount就会改变，而迭代器记录的modCount是开始迭代之前的，如果两个不一致，就会报异常，说明有两个线路（线程）同时操作集合。这种操作有风险，为了保证结果的正确性，避免这样的情况发生，一旦发现modCount与expectedModCount不一致，立即保错。

（expectedModCount是单独存储在HashMap的各种iterator中，有KeyIterator，ValueIterator，EntryIterator）

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

compute()

HashMap实现了Map接口，Map接口中有个compute方法。

default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    V oldValue = get(key);

    V newValue = remappingFunction.apply(key, oldValue);
    if (newValue == null) {
        // delete mapping
        if (oldValue != null || containsKey(key)) {
            // something to remove
            remove(key);
            return null;
        } else {
            // nothing to do. Leave things as they were.
            return null;
        }
    } else {
        // add or replace old mapping
        put(key, newValue);
        return newValue;
    }
}

首先根据BiFunction得出newValue，若不为null，则put(key, newValue)，返回newValue；若为null，则返回null，另外如果key存在，则删去key；若key不存在，则啥也不干。

简而言之，就是拓展了Function的功能，使其应用到Map上。

为什么多线程下put会导致get出现死循环？

主要原因在于 并发下的扩容会造成元素之间会形成⼀个循环链表。不过， jdk 1.8 后解决了这个问
题，但是依然有其他的弊端，比如数据丢失等等，因此多线程情况下还是建议使用concurrenthashmap。

java中hashmap多线程并发问题详解