曹工说JDK源码（1）--ConcurrentHashMap，扩容前你们同在一个哈希桶，为啥扩容后，你去新数组的高位，我只能去低位？

如何计算，一对key/value应该放在哪一个哈希桶

你们都知道，hashmap底层是数组+链表（不讨论红黑树的状况），其中，这个数组，咱们通常叫作哈希桶，你们若是去看jdk的源码，会发现里面有一些变量，叫作bin，这个bin，就是桶的意思，结合语境，就是哈希桶。

这里举个例子，假设一个hashmap的数组长度为4（0000 0100），那么该hashmap就有4个哈希桶，分别为bucket[0]、bucket[1]、bucket[2]、bucket[3]。

如今有两个node，hashcode分别是1（0000 0001），5（0000 0101）. 咱们固然知道，这两个node，都应该放入第一个桶，毕竟1 mod 4，5 mod 4的结果，都是1。

可是，在代码里，可不是用取模的方法来计算的，而是使用下面的方式：

int entryNodeIndex = (tableLength - 1) & hash;

应该说，在tableLength的值，为2的n次幂的时候，二者是等价的，可是由于位运算的效率更高，所以，代码通常都使用位运算，替代取模运算。

下面咱们看看具体怎么计算：

此处，tableLength即为哈希表的长度，此处为4. 4 - 1为3，3的二进制表示为：

0000 0011

那么，和咱们的1（0000 0001）相与：

0000 0001 -------- 1
0000 0011 -------- 3（tableLength - 1）
    相与（同为1，则为1；不然为0）
0000 0001 -------- 1

结果为1，因此，应该放在第1个哈希桶，即数组下标为1的node。

接下来，看看5这个hashcode的节点要放在什么位置，是怎么计算：

0000 0101 -------- 5
0000 0011 -------- 3（tableLength - 1）
    相与（同为1，则为1；不然为0）后结果：
0000 0001 -------- 1

扩容时，是怎么对一个hash桶进行transfer的

此处，具体的整个transfer的细节，咱们本讲不会涉及太多，不过，大致的逻辑，咱们能够来想想。

之前面为例，哈希表一共4个桶，其中bucket[1]里面，存放了两个元素，假设是a、b，其hashcode分别是1，5.

如今，假设咱们要扩容，通常来讲，扩容的时候，都是新建一个bucket数组，其容量为旧表的一倍，这里旧表为4，那新表就是8.

那，新表创建起来了，旧表里的元素，就得搬到新表里面去，等全部元素都搬到新表了，就会把新表和旧表的指针交换。以下：

java.util.concurrent.ConcurrentHashMap#transfer

    private transient volatile Node<K,V>[] nextTable;

	transient volatile Node<K,V>[] table;

if (finishing) {
    // 1
    nextTable = null;
    // 2
    table = nextTab;
    // 3
    sizeCtl = (tabLength << 1) - (tabLength >>> 1);
    return;
}

• 1处，将field：nextTable（也就是新表）设为null，扩容完了，这个field就会设为null

• 2处，将局部变量nextTab，赋值给table，这个局部变量nextTab里，就是当前已经扩容完毕的新表

• 3处，修改表的sizeCtl为：假设此处tabLength为4，tabLength << 1 左移1位，就是8；tabLength >>> 1，右移一位，就是2，。8 - 2 = 6，正好就等于 8（新表容量） * 0.75。

  因此，这里的sizeCtl就是，新表容量 * 负载因子，超过这个容量，基本就会触发扩容。

ok，接着说，咱们要怎么从旧表往新表搬呢？ 那之前面的bucket[1]举例，遍历这个链表，计算各个node，应该放到新表的什么位置，不就完了吗？是的，理论上这么写就完事了。

可是，咱们会怎么写呢？

用hashcode对新bucket数组的长度取余吗？

jdk对效率的追求那么高，确定不会这么写的，咱们看看，它怎么写的：

java.util.concurrent.ConcurrentHashMap#transfer

// 1
for (Node<K,V> p = entryNode; p != null; p = p.next) {
    // 2
    int ph = p.hash;
    K pk = p.key;
    V pv = p.val;
    
	// 3
    if ((ph & tabLength) == 0){
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    }
    else{
        highEntryNode = new Node<K,V>(ph, pk, pv, highEntryNode);
    }
}

• 1处，即遍历旧的哈希表的某个哈希桶，假设就是遍历前面的bucket[1]，里面有a/b两个元素，hashcode分别为1，5那个。

• 2处，获取该节点的hashcode，此处分别为1，5

• 3处，若是hashcode 和 旧表长度相与，结果为0，则，将该节点使用头插法，插入新表的低位；若是结果不为0，则放入高位。

  ok，什么是高位，什么是低位。扩容后，新的bucket数组，长度为8，那么，前面bucket[1]中的两个元素，将分别放入bucket[1]和bucket[5].

  ok，这里的bucket[1]就是低位，bucket[5]为高位。

首先，你们要知道，hashmap中，容量老是2的n次方，请紧紧记住这句话。

为何要这么作？你想一想，这样是否是扩容很方便？

之前，hashcode 为1，5的，都在bucket[1]；而如今，扩容为8后，hashcode为1的，仍是在newbucket[1]，hashcode为5的，则在newbucket[5]；这样的话，是否是有一半的元素，根本不用动？

这就是我以为的，最大的好处；另外呢，运算也比较方便，均可以使用位运算代替，效率更高。

好的，那咱们如今问题来了，下面这句的原理是什么？

if ((ph & tabLength) == 0){
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    } else{
        highEntryNode = new Node<K,V>(ph, pk, pv, highEntryNode);
    }

为啥，hashcode & 旧哈希表的容量， 结果为0的，扩容后，就会在低位，也就是维持位置不变呢？而结果不为0的，扩容后，位置在高位呢？

背后的位运算原理（大白话）

代码里用的以下判断，知足这个条件，去低位；不然，去高位。

if ((ph & tabLength) == 0)

仍是用前面的例子，假设当前元素为a，hashcode为1，和哈希桶大小4，去进行与运算。

0000 0001  ---- 1
0000 0100  ---- 旧哈希表容量4
&运算（同为1则为1，不然为0）
结果：
0000 0000  ---- 结果为0

ok，这里算出来，结果为0；什么状况下，结果会为0呢？

那咱们如今开始倒推，什么样的数，和 0000 0100 相与，结果会为0？

???? ????  ---- 
0000 0100  ---- 旧哈希表容量
&运算（同为1则为1，不然为0）
结果：
0000 0000  ---- 结果为0

由于与运算的规则是，同为1，则为1；不然都为0。那么，咱们这个例子里，旧哈希表容量为 0000 0100，假设表示为2的n次方，此处n为2，咱们仅有第三位（第n+1）为1，那若是对方这一位为0，那结果中的这一位，就会为0，那么，整个数，就为0.

因此，咱们的结论是：假设哈希表容量，为2的n次方，表示为二进制后，第n+1位为1；那么，只要咱们节点的hashcode，在第n+1位上为0，则最终结果是0.

反之，若是咱们节点的hashcode，在第n+1位为1，则最终结果不会是0.

好比，hashcode为5的时候，会是什么样子？

0000 0101  ---- 5
0000 0100  ---- 旧哈希表容量
&运算（同为1则为1，不然为0）
结果：
0000 0100  ---- 结果为4

此时，5这个hashcode，在第n+1位上为1，因此结果不为0。

至此，咱们离答案好像还很远。ok，不慌，继续。

假设如今扩容了，新bucket数组，长度为8.

a元素，hashcode依然是1，a元素应该放到新bucket数组的哪一个bucket里呢？

咱们用前面说的这个算法来计算：

int entryNodeIndex = (tableLength - 1) & hash;

0000 0001  ---- 1
0000 0111  ---- 8 - 1 = 7
&运算（同为1则为1，不然为0）
结果：
0000 0001  ---- 结果为1

结果没错，确实应该放到新bucket[1]，但怎么推论出来呢？

// 1
	if ((ph & tabLength) == 0){
        // 2
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    }

也就是说，假设一个数，知足1处的条件：(ph & tabLength) == 0，那怎么推论出2呢，即应该在低位呢？

ok，条件1，前面分析了，能够得出：

这个数，第n+1位为0.

接下来，看看数组长度 - 1这个数。

数组长度	2的n次方	二进制表示	1出现的位置	数组长度-1	数组长度-1的二进制
2	2的1次方	0000 0010	第2位	1	0000 0001
4	2的2次方	0000 0100	第3位	3	0000 0011
8	2的3次方	0000 1000	第4位	7	0000 0111

好了，两个数都有了，

???????0???????   -- 1 节点的hashcode，第n + 1位为0
000000010000000   -- 2 老数组    
000000100000000   -- 3 新数组的长度，等于老数组长度 * 2
000000011111111   -- 4 新数组的长度 - 1
    
    运算：1和4相与

你们注意看红字部分，还有框出来的那一列，这一列为0，致使，最终结果，确定是比2那一行的数字小，2这行，不就是老数组的长度吗，那你比老数组小；你比这一行小，在新数组里，就只能在低位了。

反之，若是节点的hashcode，这一位为1，那么，最终结果，至少是大于等于2这一行的数字，因此，会放在高位。

参考资料

https://www.jianshu.com/p/2829fe36a8dd