Java并发---HashMap的奇怪知识点

1、hashmap初始化的容量会发生变化吗？

注意：这里用的是1.7的jdk。

public static void main(String[] args) {
    Map map = new HashMap(11);
    map.put("sss",111);
}

问题：在上面的代码中，我们初始化了一个Hashmap的初始化容量是11，可是它的容量真的是11吗？
答复：答案是不是的，请看下面源码分析：
当我们点击put方法时，发现代码是这样子的

public V put(K key, V value) {
	// 这里判断map是否为空，如果为空，则初始化map，走下面代码
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    // 计算hash散列值
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    // 处理hash冲突
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    // 扩容并转移数据，在里面的resize方法的transfer方法
    addEntry(hash, key, value, i);
    return null;
}

private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    // roundUpToPowerOf2 方法会将一个数值强行转化为2的n次幂
    // 1、必须最接近size
    // 2、必须 >= size
    // 3、必须是2的n次幂
    // 所以上面传入的是11的话，转化后就是16，如果是17的话，转化后就是32
    int capacity = roundUpToPowerOf2(toSize);
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    // 这里就是初始化hashcode
    initHashSeedAsNeeded(capacity);
}

综上代码分析，我们发现即使我们传入的不是2的n次幂，hashmap也会自动给我们转化为2的n次幂。

2、hashmap初始化的容量为什么会发生变化？

因为当一个数字是2的n次幂时，会有如下代码效果。

// x 为任意数
int a = x % 2^n;
int b = x & ( 2^n - 1 );

上面的代码中a和b的结果都是一样的，但是b的运算速度比a要快的多，所以，会把我们的容量转化为2的n次幂（2ⁿ）。

3、jdk7的hashmap扩容死锁问题。

在haspmap扩容时，由于在put方法解决hash冲突采用的是头插法，所以在扩容时，如果之前数组产生过hash冲突的几个数据在rehash之后放到新数组中仍然产生hash冲突，那么就会把数据翻过来，如果是多线程的话，就会产生闭环，出现死锁。
产生问题的原因：rehash之后用了头插法就产生了这种问题。
复制数据源码如下：

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            // 就是下面这几行代码导致了链表的反转
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

4、为什么hashmap的扩展因子是0.75？

1、如果是0.5的话，将会是一种空间换时间的方法，就是说如果我们的空间有4G，那么就只能用2G，这样子显然有点浪费。
2、如果是1的话，会产生大量的冲突。
0.75的由来：其实这个扩展因子的考虑点就在于减少我们的hash冲突，这个数据取决于一个公式，叫牛顿二项式，其实当时算出来的数据是0.693，而每个语言的取值都不相同，java的hashmap取值为0.75，可能就是一种空间与时间效率的折中吧。

5、jdk8的hashmap数组与红黑树转换。

注意：这里用的是1.8的jdk。

jdk8的hashmap数组与红黑树的转换规则：
条件成立：当hashmap容量大于等于 64 时，并且一个位桶数组上的长度大于8时，才会将链表转换为红黑树。
条件不成立：如果只有链表长度大于8，而容量小于64时，是优先扩容的。
源码如下：

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // MIN_TREEIFY_CAPACITY 的值为64
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
    	// 条件不成立，扩容
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
    	// 条件成立，链表转红黑树
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

6、jdk8如何解决jdk7扩容死锁问题。

先看一下jdk8的扩容代码：
在hashMap类的resize()方法

Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
    next = e.next;
    // 与我们的容量取 & 运算，比如说容量是16 ，则只会得出结果为16 或者 0
    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;
}
// 高位数组会放在槽位数值加上旧的数组容量（也就是16）的新数组槽位下
if (hiTail != null) {
    hiTail.next = null;
    newTab[j + oldCap] = hiHead;
}

这里的代码比较复杂，我在这块就简单介绍一下大概的逻辑
首先这段代码去掉了rehash，并且定义了四个指针 loHead ，loTail ，hiHead ，hiTail 。
代码中也可以看到会去做 & 运算，结果会产生高低位，16 算高位，0 算低位，将会把一条链表分为两条链表，低位的话直接挪到新数组相同的槽位下，高位数组会放在槽位数值加上旧的数组容量（也就是16）的新数组槽位下，这样就避免了头插法形成的闭环，在代码中看注释这就话就很容易理解了。
这是数学的推理，记住结论即可，当然数组的容量必须是2的n次幂。

7、hashmap为什么在链表长度大于8的时候才转红黑树？

问题：为什么这个阈值是8，而不是其它数字，有什么区别吗？
答：如果仔细看HashMap源码时就会发现在负载因子为0.75时，hashMap采用泊松分布算法，算出每个槽位在链表各个长度时，有数据落到该槽位的概率，为8的时候概率已经很小了，所以 取了8这个阈值，如下图所示：