Java并发------HashMap和ConcurrentHashMap详解

HashMap

HashMap 和 HashSet 是 Java Collection Framework 的两个重要成员，其中 HashMap 是 Map 接口的常用实现类，HashSet 是 Set 接口的常用实现类。虽然 HashMap 和 HashSet 实现的接口规范不同，但它们底层的 Hash 存储机制完全一样，甚至 HashSet 本身就采用 HashMap 来实现的。
通过 HashMap、HashSet 的源代码分析其 Hash 存储机制

实际上，HashSet 和 HashMap 之间有很多相似之处，对于 HashSet 而言，系统采用 Hash 算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；对于 HashMap 而言，系统 key-value 当成一个整体进行处理，系统总是根据 Hash 算法来计算 key-value 的存储位置，这样可以保证能快速存、取 Map 的 key-value 对。

在介绍集合存储之前需要指出一点：虽然集合号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入 Set 集合中，只是在 Set 集合中保留这些对象的引用而言。也就是说：Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java 对象。

1、HashMap 的存储实现

• jdk7 的 HashMap 结构是：数组+链表；
• jdk8 的 HashMap 结构是：数组+链表+红黑树

当程序试图将多个 key-value 放入 HashMap 中时，以如下代码片段为例：

HashMap<String , Double> map = new HashMap<String , Double>();   
map.put("语文" , 80.0);   
map.put("数学" , 89.0);   
map.put("英语" , 78.2);

HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。

当程序执行 map.put(“语文” , 80.0); 时，系统将调用"语文"的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode 值来决定该元素的存储位置。

我们可以看 HashMap 类的 put(K key , V value) 方法的源代码：

/*
 * jdk7
 */
public V put(K key, V value) {
    //第一次存储元素，初始化
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 如果 key 为 null，调用 putForNullKey 方法进行处理
    if (key == null)
        return putForNullKey(value);
    // 根据 key 的 keyCode 计算 Hash 值
    int hash = hash(key);
    // 搜索指定 hash 值在对应 table 中的索引
    int i = indexFor(hash, table.length);
    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素
    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;
        }
    }
    // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry
    modCount++;
    // 将 key、value 添加到 i 索引处  
    addEntry(hash, key, value, i);
    return null;
}  

/*
 * jdk8
 */
final V 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)
        n = (tab = resize()).length;
    //计算数组的索引位置是否有元素，没有元素的话直接在该索引处存储新元素即可
    //（tab.length - 1）& hash这个方法与jdk7的indexFor方法一样
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //如果这个位置有元素，并且与原位置上的元素相等的话，直接返回这个要存储的元素即可
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //如果这个位置有元素，并且与原位置上的元素不等的话，判断是否是红黑树
        else if (p instanceof HashMap.TreeNode)
            //新元素放置到entry链的头部，moveRootToFront这个方法中
            e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //如果这个位置有元素，并且与原位置上的元素不等的话，不是红黑树即是链表
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    //插入新元素到链表最尾
                    p.next = newNode(hash, key, value, null);
                    //如果链表个数超过8个，会进行具体的判断，选择扩容数组或者链表转为红黑树
                    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;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            //如果已有这个key，node的值指向新值value
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //插入元素后检查是否需要进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。

hash()，这个方法是一个纯粹的数学计算，jdk7 与jdk8 的计算方法有些许不同：

/*
 * jdk7
 */
 static int hash(int h)   
{   
    h ^= (h >>> 20) ^ (h >>> 12);   
    return h ^ (h >>> 7) ^ (h >>> 4);   
}

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

对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。jdk7 采用接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。jdk8 也是使用 tab[i = (n - 1) & hash] 来计算索引位置：

/*
 * jdk7
 */
static int indexFor(int h, int length)   
{   
    return h & (length-1);   
}

这个方法非常巧妙，它总是通过 h & (table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方，这一点可参看后面关于 HashMap 构造器的介绍。通过一下代码可以看出计算索引位置的原理：

/*
 * 以"语文"作为key，计算索引位置，得到index为10
 */
int keyHashCode = "语文".hashCode();//keyHashCode结果为1136442
int tableLength = 15;
int index1 = keyHashCode & tableLength;//index1结果为10
/*
 * 实现原理
 */
String keyBinaryString = Integer.toBinaryString(keyHashCode);//keyBinaryString结果为100010101011100111010
String tableBinaryString = Integer.toBinaryString(tableLength);//tableBinaryString结果为1111
/*
 *   100010101011100111010
 * & 000000000000000001111
 * -----------------------
 *   000000000000000001010
 */
Integer index2 = Integer.valueOf("1010", 2);//index2结果为10

通过这种与运算，可以看出index1和index2结果一致，这样计算的好处就是最后得到的索引值注定不会超过原来的table的大小。

根据上面 put 方法的源代码可以看出，当程序试图将一个 key-value 对放入 HashMap 中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但 key 不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链。

当向 HashMap 中添加 key-value 对，由其 key 的 hashCode() 返回值决定该 key-value 对（就是 Entry 对象）的存储位置。当两个 Entry 对象的 key 的 hashCode() 返回值相同时，将由 key 通过 eqauls() 比较值决定是采用覆盖行为（返回 true），还是产生 Entry 链（返回 false）。

上面程序中还调用了 addEntry(hash, key, value, i) 代码，其中 addEntry 是 HashMap 提供的一个包访问权限的方法，该方法仅用于添加一个 key-value 对。下面是该方法的代码：

/*
 * jdk7
 */
void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        createEntry(hash, key, value, bucketIndex);
    }
void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
//新生成entry的next指针永远指向原位置上的entry    
static class Entry<K,V> implements Map.Entry<K,V> {
    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }  
}   
  
/*
 * jdk8
 */ 
if ((e = p.next) == null) {
    //插入新元素到链表最尾
    p.next = newNode(hash, key, value, null);
    //如果链表个数超过8个，会进行具体的判断，选择扩容数组或者链表转为红黑树
    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
        treeifyBin(tab, hash);
    break;
}

这两端代码体现了 jdk8 和 jdk7 的 entry 链表插入新元素时的不同方式，jdk7 是插入链表头部，jdk8 是插入链表尾部；jdk8 会在链表长度达到 8 时，并且数组长度达到 64 以上时，自动把链表转为红黑树，从而获得更好的性能。

2、Hash 算法的性能选项

根据上面代码可以看出，在同一个 bucket 存储 Entry 链的情况下，新放入的 Entry 总是位于 bucket 中，而最早放入该 bucket 中的 Entry 则位于这个 Entry 链的最末端或者最前端。

上面程序中还有这样两个变量：

* size：该变量保存了该 HashMap 中所包含的 key-value 对的数量。
* threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）。

从上面程序中②号代码可以看出，当 size++ >= threshold 时，HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次，HashMap 的容量就增大一倍。

上面程序中使用的 table 其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是 HashMap 的容量。HashMap 包含如下几个构造器：

* HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
* HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
* HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。

当创建一个 HashMap 时，系统会自动创建一个 table 数组来保存 HashMap 中的 Entry，下面是 HashMap 中一个构造器的代码：

/*
 * jdk7的初始化和扩容
 */ 
public HashMap(int initialCapacity, float loadFactor) {
    // 初始容量不能为负数
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                initialCapacity);
    // 如果初始容量大于最大容量，让出示容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // 负载因子必须大于 0 的数值
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                loadFactor);
    this.loadFactor = loadFactor;
    // 设置容量极限等于容量 * 负载因子
    threshold = initialCapacity;
    init();
}

public V put(K key, V value) {
    //第一次存储元素时初始化容量
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    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++;
    addEntry(hash, key, value, i);
    return null;
}

private void inflateTable(int toSize) {
    // 计算所需容量
    int capacity = roundUpToPowerOf2(toSize);
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

private static int roundUpToPowerOf2(int number) {
    //① 容量初始化
    return number >= MAXIMUM_CAPACITY
            ? MAXIMUM_CAPACITY
            : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
    	//当前数组容量的2倍进行扩容
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    Entry[] newTable = new Entry[newCapacity];
    //复制数组
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

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);
            }
            //②需要重新计算entry的索引位置
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

/*
 * jdk8的初始化和扩容
 */ 
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;
    this.threshold = tableSizeFor(initialCapacity);
}

//①容量初始化
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;
}

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;
        }
        //位运算，新容量是原容量一倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    //如果是初始化，容量设置为threshold
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        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;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new HashMap.Node[newCap];
    table = newTab;
    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)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof HashMap.TreeNode)
                    ((HashMap.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;
                        //②位运算计算出与原索引的最高位是否是0，是0索引不变
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        //不是0，原索引加上扩容大小为新索引
                        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;
}

分开看 jdk7 和 jdk8 的初始化代码，table 的实质就是一个数组，一个长度为 capacity 的数组。看上面代码注释①，两者虽然初始化方法不同，但是都是通过相应的算法计算出capacity 的这个值，这个值才代表了实际的map容量大小，也就是说无论指定初始化的大小是多少，初始化后的容量始终是16的倍数，即给定 initialCapacity 为 10，map 的实际容量是 16；给定initialCapacity 为 33，map的实际容量是64。

为什么要严格的设定容量是16或者16的倍数？因为16的hash值是10000，这个数值对于扩容的计算会特别快，继续看计算索引的代码示例：

/*
 * 以"语文"作为key，计算索引位置，得到index为10
 */
int keyHashCode1 = "语文".hashCode();//keyHashCode1结果为1136442
int keyHashCode2 = "生物".hashCode();//keyHashCode2结果为958762
int tableLength = 15;
int index1 = keyHashCode1 & tableLength;//index1结果为10
int index2 = keyHashCode2 & tableLength;//index2结果为10

/*
 * 实现原理
 */
String keyBinaryString1 = Integer.toBinaryString(keyHashCode1);//keyBinaryString1结果为100010101011100111010
String keyBinaryString2 = Integer.toBinaryString(keyHashCode2);//keyBinaryString2结果为11101010000100101010
String tableBinaryString = Integer.toBinaryString(tableLength);//tableBinaryString结果为1111
/*
 *   100010101011100111010
 * & 000000000000000001111
 * -----------------------
 *   000000000000000001010
 *
 *   011101010000100101010
 * & 000000000000000001111
 * -----------------------
 *   000000000000000001010
 *
 */
Integer myIndex1 = Integer.valueOf("1010", 2);//myIndex1结果为10
Integer myIndex2 = Integer.valueOf("1010", 2);//myIndex2结果为10

/*
 * 扩容后
 */
tableLength = 31;
index1 = keyHashCode1 & tableLength;//index1结果为26
index2 = keyHashCode2 & tableLength;//index2结果为10

/*
 * 扩容后实现原理
 */
tableBinaryString = Integer.toBinaryString(tableLength);//tableBinaryString结果为11111
/*
 *   100010101011100111010
 * & 000000000000000011111
 * -----------------------
 *   000000000000000011010
 *                   ↓          
 *                   1
 *
 *   011101010000100101010
 * & 000000000000000011111
 * -----------------------
 *   000000000000000001010
 *                   ↓
 *                   0
 */
myIndex1 = Integer.valueOf("11010", 2);//myIndex1结果为26
myIndex2 = Integer.valueOf("1010", 2);//myIndex2结果为10

看一下这个实现原理：两个不同的 key 通过 keyHashCode & （tableLength - 1）这个简单的位运算得到一个索引值，扩容后再次得到一个新索引值，这个新的索引值与原来的索引值有很大关系：

如果容量的最高位（1）与 key 对应此位置的数值（1）正好一致的话，则计算结果最高位较原计算结果最高位多一个 1，也就是新索引值比原索引值大10000 ；如果容量的最高位（1）与 key 对应此位置的数值（0）不一致的话，那么计算结果与原计算结果一致。而 16 的二进制值是10000，32 的二进制是 100000 ，以此类推，如果计算结果多出的 10000 就是 16 ，也就是原索引值需要增加 16 ，16 恰好就是原容量值。换句话说，得到的新索引值，不是原索引值就一定是原索引值加上原容量后的值。

上面这段计算对于 hashmap 存储数据来说有什么帮助呢？也许对于 jdk7 来说很小，但是对于 jdk8 来说帮助却是特别大。因为上面的分析可以看到，其实我们只需要把新索引值的二进制值与原索引值的二进制值的最高位进行比较即可，如果最高位的位数多一位的话，说明需要加大索引值；如果位数一致 ，说明使用原索引值即可。为什么说这对于 jdk7 帮助很小呢？看上面代码注释②，jdk7 进行扩容时需要每个元素重新计算新的索引值，而jdk8 通过这个方法来判断：

if ((e.hash & oldCap) == 0)

这个方法的巧妙在哪呢？其实我们看上面的代码， tableLength - 1 的原容量 16 - 1的二进制值是 1111，扩容后的 32 - 1 的二进制值是 11111 ，我们最后判断索引值是否改变的标准就是看 key 值的 “↓” 下箭头这个位置的数字是否是 1 ，是 1 则改变索引值， 是 0 则索引值不变。那么怎么简单的判断 key 二进制值中指定位置的数字是否是 0 呢？很简单，原容量 16 二进制值恰好是 10000， 也就是说 key 二进制值与 10000，做个与运算即可。如果 “↓” 下箭头这个位置的数字正好是 0 ，那么与 10000 的位运算计算结果也必定是0。下面看代码：

以“语文”和“生物”这两个key的hashcode二进制值为例，看一下 if ((e.hash & oldCap) == 0) 的原理：
/*
 *   key：语文
 *   100010101011100111010
 * & 000000000000000010000
 * -----------------------
 *   000000000000000010000
 * 
 *   key：生物
 *   011101010000100101010
 * & 000000000000000010000
 * -----------------------
 *   000000000000000000000
 */

最终我们通过这样的运算，得到 0 或者 非 0 的结果，我们也以此来判断是否使用原索引值。这就是初始容量是 16 的好处，可以通过简单的位运算得到索引值，而不需要像 jdk7 那样每个重新计算一次，这也是为什么每次扩容后的值一定是 16 的偶数倍。

3、HashMap 的读取实现

当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时，此时的 HashMap 具有最好的性能：当程序通过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，然后取出该索引处的 Entry，最后返回该 key 对应的 value 即可。看 HashMap 类的 get(K key) 方法代码：

/*
 * jdk7
 */
public V get(Object key) {
    // 如果 key 是 null，调用 getForNullKey 取出对应的 value   
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : hash(key);
    // 直接取出 table 数组中指定索引处的值，
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        // 如果该 Entry 的 key 与被搜索 key 相同  
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/*
 * jdk8
 */
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        //每次都先检查第一个元素是否匹配
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            //如果node类型是红黑树查找到key即可
            if (first instanceof HashMap.TreeNode)
                return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
            //如果node类型是链表，一个个向下查找即可
            do {
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

从上面代码中可以看出，如果 HashMap 的每个 bucket 里只有一个 Entry 时，HashMap 可以根据索引、快速地取出该 bucket 里的 Entry；在发生“Hash 冲突”的情况下，单个 bucket 里存储的不是一个 Entry，而是一个 Entry 链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），那系统必须循环到最后才能找到该元素。这也是为什么jdk8引入红黑树的原因，当链表长度大于8时，把链表转为红黑树存储，这样在查询时不需要每个遍历一次来找到相应的key。

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。由此可见：HashMap 之所以能快速存、取它所包含的 Entry，完全类似于现实生活中母亲从小教我们的：不同的东西要放在不同的位置，需要时才能快速找到它。

当创建 HashMap 时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。

掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。

如果开始就知道 HashMap 会保存多个 key-value 对，可以在创建时就使用较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity * load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity 的 Entry 数组），因此创建 HashMap 时初始化容量设置也需要小心对待。

ConcurrentHashMap

这部分是后来补充学习了一下，没有去看 jdk7 的 ConcurrentHashMap 源码，简单的看了下 jdk8 的 ConcurrentHashMap 源码。jdk7 的 ConcurrentHashMap 结构是 Segment 数组，每个 Segment 数组里面相当于有一个 HashMap，jdk8 的 ConcurrentHashMap 结构与 jdk7 差别很大，废弃了这种方式，只是在 HashMap 的基础上加入了一些并发操作，基本结构与 jdk8 的 HashMap 一样，也是数组 + 链表 + 红黑树的形式。

1、构造函数：

public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
            MAXIMUM_CAPACITY :
            tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    this.sizeCtl = cap;
}

与 HashMap 一样，构造函数中什么也不做，只是简单的计算了 sizeCtrl 这个值，这个值的计算结果最终也一定得到 16 的倍数（除非 initialCapacity 指定小于 4 的值）。

2、put方法：

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    //计算链表的长度
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        //初始化数组
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        //如果此hash值位置没有元素，直接添加node即可
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                    new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        //MOVED这个值是-1，说明数组正在扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    //如果此hash值位置的头部node节点hash值大于0，说明这是一个链表
                    if (fh >= 0) {
                        binCount = 1;
                        //计算链表长度
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            //覆盖旧值
                            if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                            (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            //插入新值
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                        value, null);
                                break;
                            }
                        }
                    }
                    //如果此hash值位置的node类型是红黑树
                    else if (f instanceof ConcurrentHashMap.TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((ConcurrentHashMap.TreeBin<K,V>)f).putTreeVal(hash, key,
                                value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            //①当计算链表长度超过8时，会进行具体的判断，选择扩容数组或者链表转为红黑树
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //用于检查是否需要扩容数组
    addCount(1L, binCount);
    return null;
}

对于插入元素时的并发问题，使用加锁和CAS操作来保证线程安全，CAS介绍：
https://blog.csdn.net/mmoren/article/details/79185862

3、数组初始化：

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        //说明其他线程正在初始化数组，等待即可
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        //抢到线程后将sizeCtl的值赋值为-1，不让其他线程进行操作
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    //默认初始容量为16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    //重新赋值后的sc值变为12，也就是16的0.75
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

4、链表转红黑树：

上面 put 方法中的代码注释①中，有一处判断，新插入元素如果是在链表位置，去要看具体情况来判断到底是需要扩容数组，还是把链表转为红黑树，下面是源码：

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        //判断数组长度是否选择扩容
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            tryPresize(n << 1);
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            synchronized (b) {
                if (tabAt(tab, index) == b) {
                    //新建红黑树，进行转换
                    ConcurrentHashMap.TreeNode<K,V> hd = null, tl = null;
                    for (Node<K,V> e = b; e != null; e = e.next) {
                        ConcurrentHashMap.TreeNode<K,V> p =
                                new ConcurrentHashMap.TreeNode<K,V>(e.hash, e.key, e.val,
                                        null, null);
                        if ((p.prev = tl) == null)
                            hd = p;
                        else
                            tl.next = p;
                        tl = p;
                    }
                    //把新转换出来的红黑树插入到数组中
                    setTabAt(tab, index, new ConcurrentHashMap.TreeBin<K,V>(hd));
                }
            }
        }
    }
}

所以此处的逻辑与 HashMap 一致，并不是一定会把链表转为红黑树，而是需要根据数组的长度而来，只有当数组长度超过 64 时，才会进行链表与红黑树的转换，否则扩容数组即可。

5、数组扩容：

private final void tryPresize(int size) {
    //数组直接根据size的值进行扩容
    int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
            tableSizeFor(size + (size >>> 1) + 1);
    int sc;
    while ((sc = sizeCtl) >= 0) {
        Node<K,V>[] tab = table; int n;
        //这个与初始化代码一样
        if (tab == null || (n = tab.length) == 0) {
            n = (sc > c) ? sc : c;
            if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if (table == tab) {
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        //不是初始化的话直接进行扩容，然后进行数据迁移
        else if (tab == table) {
            int rs = resizeStamp(n);
            //已经有线程在扩容，帮助扩容即可
            if (sc < 0) {
                Node<K,V>[] nt;
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                    break;
                //调用数据迁移方法时传入新的数组对象，并且CAS操作把sizeCtl加1
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            //此时此线程第一个进行扩容，因为sizeCtl现在是大于0的状态，把sizeCtl设置成很大的负数，调用数据迁移的方法，但是新数组传入的是null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                    (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

进行扩容时会先判断是否需要初始化，判断不需要初始化的话，就会直接进行扩容。在数组初始化时，就有一个很重要的参数：sizeCtl。判断是否自己进行初始化还是已经有线程进行初始化，判断是否自己进行扩容还是已有线程进行扩容，都是根据这个参数来的，如果这个参数为负数的话，说明已有线程进行了操作。sizeCtl 这个参数一直有CAS操作来维护。

当第一次扩容时，会把 sizeCtl 设置为一个很大的负数，后续有线程帮助扩容时会把这个值加 1，但是依旧是一个负数，由此来判断是自己进行扩容，还是帮助扩容。

另外每次 put 元素后都会进行一个检查，检查当前容量是否达到阈值，如果达到也需要扩容：

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                        U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                    (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}                                                            

这段代码前面没看懂，不过后面与 tryPresize 的扩容方法一样。

6、数据迁移：

这是最难看懂的一部分代码了：

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    //n是原数组的长度
    int n = tab.length, stride;
    //stride可以理解为任务数，主要跟cpu的参数有关，代表一条线程负责迁移的元素个数，可以当作16处理
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range
    //nextTab为null说明是第一个迁移的线程
    if (nextTab == null) {            // initiating
        try {
            @SuppressWarnings("unchecked")
            //创建一个新数组，容量翻倍
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        nextTable = nextTab;
        //原数组的数组大小
        transferIndex = n;
    }
    //nextn记录下新数组的长度，这个值用于判断，不会改变
    int nextn = nextTab.length;
    //ForwardingNode代表正在迁移的node，注意它的hash值是MOVED
    //这个很重要，在其他方法代码中都有对于这个值的判断，前面不明白MOVED这个值怎么来的应该可以理解了
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    //advance代表做完一个任务包的迁移，准备进行下一个任务包的迁移
    boolean advance = true;
    //finishing代表全部迁移完成
    boolean finishing = false; // to ensure sweep before committing nextTab
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;
        while (advance) {
            //nextIndex代表下一个开始迁移的数组元素，它的初始值是transferIndex，所以是从数组最后一个元素向前来一个个迁移的
            //nextIndex是元素的个数，最终判断需要迁移元素的索引是由i = nextIndex - 1确定的
            //nextBound相当于迁移边界的意思，注意这个--i的操作，当迁移元素的索引达到边界值，则停止迁移
            int nextIndex, nextBound;
            if (--i >= bound || finishing) {
                advance = false;
            }
            //nextIndex小于0，代表所有任务包都在执行，等待就可以了，都迁移完后finishing会为true，上个方法会退出循环
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
            }
            //这里在CAS操作下拿到下一个需要迁移的nextIndex
            //CAS操作维护TRANSFERINDEX，它预期值应该是nextIndex
            //如果与预期值一样，那么退出while循环，自己来迁移nextIndex位置的元素，并将迁移边界定义好，达到迁移边界时停止
            //如果与预期值不一样，继续while循环，当其他线程修改过transferIndex，再次拿到的nextIndex与TRANSFERINDEX一致，代表indexIndex位置的元素由自己来修改
            //TRANSFERINDEX这个变量虽然是final修饰，但是它是指向transferIndex，transferIndex由volatile关键字保证线程安全
            else if (U.compareAndSwapInt
                    (this, TRANSFERINDEX, nextIndex,
                            nextBound = (nextIndex > stride ?
                                    nextIndex - stride : 0))) {
                //bound存储了nextBound的值，用于在if (--i >= bound || finishing) 中进行判断使用
                bound = nextBound;
                //i代表需要开始迁移的索引
                i = nextIndex - 1;
                advance = false;
            }
        }
        //开始迁移
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            //这里finishing为true时，迁移直接停止
            if (finishing) {
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            //因为每个线程迁移前都会把sizeCtl加1，这里再减1后代表自己迁移完成
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        //如果i索引位置的元素为空，插入此位置一个空node即可
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        //其他线程正在迁移，不需要自己处理
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        //否则自己来做迁移，每次只会迁移一个元素，也就是i索引处的元素
        else {
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    if (fh >= 0) {
                        int runBit = fh & n;
                        Node<K,V> lastRun = f;
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        if (runBit == 0) {
                            ln = lastRun;
                            hn = null;
                        }
                        else {
                            hn = lastRun;
                            ln = null;
                        }
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            if ((ph & n) == 0)
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                    else if (f instanceof TreeBin) {
                        TreeBin<K,V> t = (TreeBin<K,V>)f;
                        TreeNode<K,V> lo = null, loTail = null;
                        TreeNode<K,V> hi = null, hiTail = null;
                        int lc = 0, hc = 0;
                        for (Node<K,V> e = t.first; e != null; e = e.next) {
                            int h = e.hash;
                            TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                            if ((h & n) == 0) {
                                if ((p.prev = loTail) == null)
                                    lo = p;
                                else
                                    loTail.next = p;
                                loTail = p;
                                ++lc;
                            }
                            else {
                                if ((p.prev = hiTail) == null)
                                    hi = p;
                                else
                                    hiTail.next = p;
                                hiTail = p;
                                ++hc;
                            }
                        }
                        ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                        hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                }
            }
        }
    }
}

其实对于这部分代码的理解，最难的在于理解while循环里面的内容，如何拿到下一个需要迁移的 nextIndex：

首先要理解 transferIndex 和 TRANSFERINDEX这两个变量的关系，TRANSFERINDEX是由 final 修饰，内存中是指向 transferIndex 这个变量的，所以我们并不是改变 final 修饰的这个变量，而是通过 CAS 操作修改 TRANSFERINDEX 指向的 transferIndex 这个变量，这个可以从静态代码块中看出；transferIndex 是由 volatile 修饰来保证线程安全的。在下面这个 else if 条件判断中：

else if (U.compareAndSwapInt
                    (this, TRANSFERINDEX, nextIndex,
                            nextBound = (nextIndex > stride ?
                                    nextIndex - stride : 0))) 

怎么保证每条线程做自己该做的，不该做的不参与呢？是通过 TRANSFERINDEX 这个参数来确定的。当我们试图修改 transferIndex 时，先检查它的预期值是否是 nextIndex，如果是，计算迁移边界 nextBound，nextBound 一定是 0 或者正数，因为步长也就是任务数 stride 最小是16，代表每条线程负责迁移 16 个元素：

• 所以当数组的容量很小时，比如 16，那就只需要一条线程来迁移即可，nextBound 直接赋值为 0，将 nextBound 赋值给 TRANSFERINDEX 指向的 transferIndex ，这样所有的 16 个元素都由此线程来迁移。这样当下一条线程进来时，发现 transferIndex 这个值已经为 0 ，将不会再去计算下次需要迁移的索引 nextIndex，因为所有元素都已经分配上一条线程了；
• 当数组容量很大，比如是 64 ，第一条线程的 nextIndex 赋值为 64，迁移边界 nextBound 赋值为 48，第二条线程的 nextIndex 赋值为 48，迁移边界 nextBound 赋值为 32，以此类推，每条线程都负责这个 nextIndex 向前的 stride 个元素的迁移工作，直到迁移边界 nextBound 这个值才会停止，如果此时 finishing 为 true，代表所有数组元素都已经迁移完成，退出方法即可；如果 finishing 不为 true，接着拿到 nextIndex 帮助完成后续的迁移。

这里说的多条线程不一定是多条线程一起执行，也能是一条线程多次执行来完成迁移。再看下面的迁移代码，每次迁移都是迁移一个元素，就是 i = nextIndex - 1 索引处的元素，迁移完成后，赋值 advance 为true，再次进入 while 循环，在第一个 if 中将 i 做一个减 1 的操作，上面代码注释中有，此时减 1 后的 i 一定没有到迁移边界 nextBound 处，所以将继续迁移减 1 后的 i 索引处的元素，直到 i 等于迁移边界 nextBound，也就是说完成了此次迁移 stride 个元素的任务。

前面的扩容代码 tryPresize 中说到，此次线程自己先进行迁移还是帮助迁移的不同是 transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) 这个方法中的第二个参数是否是 null， 如果是 null， 就现由自己这条线程来初始化新的数组，给 transferIndex 赋值，做好准备工作，后续线程进来后直接进行迁移即可。

没有给具体迁移过程的代码进行注释，因为也就是从老数组拿到一个元素，移动到新数组中，并重新计算索引的过程，这个其实不难，关键是分配迁移任务的这个思路和如何保证线程安全。jdk8 的源码其实还是特别不好理解的。