Java8 中的 HashMap 和 ConcurrentHashMap 全解析

Java8 HashMap

Java8 对 HashMap 进行了一些修改，最大的不一样就是利用了红黑树，因此其由 数组+链表+红黑树 组成。

根据 Java7 HashMap 的介绍，咱们知道，查找的时候，根据 hash 值咱们可以快速定位到数组的具体下标，可是以后的话，须要顺着链表一个个比较下去才能找到咱们须要的，时间复杂度取决于链表的长度，为 O(n)。

为了下降这部分的开销，在 Java8 中，当链表中的元素超过了 8 个之后，会将链表转换为红黑树，在这些位置进行查找的时候能够下降时间复杂度为 O(logN)。

来一张图简单示意一下吧：

注意，上图是示意图，主要是描述结构，不会达到这个状态的，由于这么多数据的时候早就扩容了。

下面，咱们仍是用代码来介绍吧，我的感受，Java8 的源码可读性要差一些，不过精简一些。

Java7 中使用 Entry 来表明每一个 HashMap 中的数据节点，Java8 中使用 Node，基本没有区别，都是 key，value，hash 和 next 这四个属性，不过，Node 只能用于链表的状况，红黑树的状况须要使用 TreeNode。

咱们根据数组元素中，第一个节点数据类型是 Node 仍是 TreeNode 来判断该位置下是链表仍是红黑树的。

put 过程分析

// 方法参数上的 node 是此次扩容后，须要添加到新的数组中的数据。
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
// 第三个参数 onlyIfAbsent 若是是 true，那么只有在不存在该 key 时才会进行 put 操做
// 第四个参数 evict 咱们这里不关心

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K, V>[] tab;
    Node<K, V> p;
    int n, i;
    // 第一次 put 值的时候，会触发下面的 resize()，相似 java7 的第一次 put 也要初始化数组长度
    // 第一次 resize 和后续的扩容有些不同，由于此次是数组从 null 初始化到默认的 16 或自定义的初始容量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 找到具体的数组下标，若是此位置没有值，那么直接初始化一下 Node 并放置在这个位置就能够了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {// 数组该位置有数据
        Node<K, V> e;
        K k;
        // 首先，判断该位置的第一个数据和咱们要插入的数据，key 是否是"相等"，若是是，取出这个节点
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
            // 若是该节点是表明红黑树的节点，调用红黑树的插值方法，本文不展开说红黑树
        else if (p instanceof TreeNode)
            e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        else {
            // 到这里，说明数组该位置上是一个链表
            for (int binCount = 0; ; ++binCount) {
                // 插入到链表的最后面(Java7 是插入到链表的最前面)
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // TREEIFY_THRESHOLD 为 8，因此，若是新插入的值是链表中的第 9 个
                    // 会触发下面的 treeifyBin，也就是将链表转换为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 若是在该链表中找到了"相等"的 key(== 或 equals)
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    // 此时 break，那么 e 为链表中[与要插入的新值的 key "相等"]的 node
                    break;
                p = e;
            }
        }
        // e!=null 说明存在旧值的key与要插入的key"相等"
        // 对于咱们分析的put操做，下面这个 if 其实就是进行 "值覆盖"，而后返回旧值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 若是 HashMap 因为新插入这个值致使 size 已经超过了阈值，须要进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

和 Java7 稍微有点不同的地方就是，Java7 是先扩容后插入新值的，Java8 先插值再扩容，不过这个不重要。

数组扩容

resize() 方法用于初始化数组或数组扩容，每次扩容后，容量为原来的 2 倍，并进行数据迁移。

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
    } else if (oldThr > 0) // 对应使用 new HashMap(int initialCapacity) 初始化后，第一次 put 的时候
        newCap = oldThr;
    else {// 对应使用 new HashMap() 初始化后，第一次 put 的时候
        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;
    // 用新的数组大小初始化新的数组
    Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
    table = newTab; // 若是是初始化数组，到这里就结束了，返回 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 TreeNode)
                    ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                else {
                    // 这块是处理链表的状况，
                    // 须要将此链表拆成两个链表，放到新的数组中，而且保留原来的前后顺序
                    // loHead、loTail 对应一条链表，hiHead、hiTail 对应另外一条链表，代码仍是比较简单的
                    Node<K, V> loHead = null, loTail = null;
                    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;
                        // 第二条链表的新的位置是 j + oldCap，这个很好理解
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

get 过程分析

相对于 put 来讲，get 真的太简单了。

1. 计算 key 的 hash 值，根据 hash 值找到对应数组下标: hash & (length-1)

2. 判断数组该位置处的元素是否恰好就是咱们要找的，若是不是，走第三步

3. 判断该元素类型是不是 TreeNode，若是是，用红黑树的方法取数据，若是不是，走第四步

4. 遍历链表，直到找到相等(==或equals)的 key

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

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) {
            // 判断是不是红黑树
            if (first instanceof TreeNode)
                return ((TreeNode<K, V>) first).getTreeNode(hash, key);
            // 链表遍历
            do {
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

Java8 ConcurrentHashMap

Java7 中实现的 ConcurrentHashMap 说实话仍是比较复杂的，Java8 对 ConcurrentHashMap 进行了比较大的改动。建议读者能够参考 Java8 中 HashMap 相对于 Java7 HashMap 的改动，对于 ConcurrentHashMap，Java8 也引入了红黑树。

说实话，Java8 ConcurrentHashMap 源码真心不简单，最难的在于扩容，数据迁移操做不容易看懂。

咱们先用一个示意图来描述下其结构：

结构上和 Java8 的 HashMap 基本上同样，不过它要保证线程安全性，因此在源码上确实要复杂一些。

初始化

// 这构造函数里，什么都不干
public ConcurrentHashMap() {
}

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;
}

这个初始化方法有点意思，经过提供初始容量，计算了 sizeCtl，sizeCtl = 【 (1.5 * initialCapacity + 1)，而后向上取最近的 2 的 n 次方】。如 initialCapacity 为 10，那么获得 sizeCtl 为 16，若是 initialCapacity 为 11，获得 sizeCtl 为 32。

sizeCtl 这个属性使用的场景不少，不过只要跟着文章的思路来，就不会被它搞晕了。

若是你爱折腾，也能够看下另外一个有三个参数的构造方法，这里我就不说了，大部分时候，咱们会使用无参构造函数进行实例化，咱们也按照这个思路来进行源码分析吧。

put 过程分析

仔细地一行一行代码看下去：

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

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 获得 hash 值
    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 值对应的数组下标，获得第一个节点 f
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 若是数组该位置为空，
            //    用一次 CAS 操做将这个新值放入其中便可，这个 put 操做差很少就结束了，能够拉到最后面了
            //          若是 CAS 失败，那就是有并发操做，进到下一个循环就行了
            if (casTabAt(tab, i, null,
                    new Node<K, V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // hash 竟然能够等于 MOVED，这个须要到后面才能看明白，不过从名字上也能猜到，确定是由于在扩容
        else if ((fh = f.hash) == MOVED)
            // 帮助数据迁移，这个等到看完数据迁移部分的介绍后，再理解这个就很简单了
            tab = helpTransfer(tab, f);
        else { // 到这里就是说，f 是该位置的头结点，并且不为空
            V oldVal = null;
            // 获取数组该位置的头结点的监视器锁
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 头结点的 hash 值大于 0，说明是链表
                        // 用于累加，记录链表的长度
                        binCount = 1;
                        // 遍历链表
                        for (Node<K, V> e = f; ; ++binCount) {
                            K ek;
                            // 若是发现了"相等"的 key，判断是否要进行值覆盖，而后也就能够 break 了
                            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;
                            }
                        }
                    } else if (f instanceof TreeBin) { // 红黑树
                        Node<K, V> p;
                        binCount = 2;
                        // 调用红黑树的插值方法插入新节点
                        if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key,
                                value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            // binCount != 0 说明上面在作链表操做
            if (binCount != 0) {
                // 判断是否要将链表转换为红黑树，临界值和 HashMap 同样，也是 8
                if (binCount >= TREEIFY_THRESHOLD)
                    // 这个方法和 HashMap 中稍微有一点点不一样，那就是它不是必定会进行红黑树转换，
                    // 若是当前数组的长度小于 64，那么会选择进行数组扩容，而不是转换为红黑树
                    //    具体源码咱们就不看了，扩容部分后面说
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 
    addCount(1L, binCount);
    return null;
}

put 的主流程看完了，可是至少留下了几个问题，第一个是初始化，第二个是扩容，第三个是帮助数据迁移，这些咱们都会在后面进行一一介绍。

初始化数组：initTable

这个比较简单，主要就是初始化一个合适大小的数组，而后会设置 sizeCtl。

初始化方法中的并发问题是经过对 sizeCtl 进行一个 CAS 操做来控制的。

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
            // CAS 一下，将 sizeCtl 设置为 -1，表明抢到了锁
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // DEFAULT_CAPACITY 默认初始容量是 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 初始化数组，长度为 16 或初始化时提供的长度
                    Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
                    // 将这个数组赋值给 table，table 是 volatile 的
                    table = tab = nt;
                    // 若是 n 为 16 的话，那么这里 sc = 12
                    // 其实就是 0.75 * n
                    sc = n - (n >>> 2);
                }
            } finally {
                // 设置 sizeCtl 为 sc，咱们就当是 12 吧
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

链表转红黑树: treeifyBin

前面咱们在 put 源码分析也说过，treeifyBin 不必定就会进行红黑树转换，也多是仅仅作数组扩容。咱们仍是进行源码分析吧。

private final void treeifyBin(Node<K, V>[] tab, int index) {
    Node<K, V> b;
    int n, sc;
    if (tab != null) {
        // MIN_TREEIFY_CAPACITY 为 64
        // 因此，若是数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            // 后面咱们再详细分析这个方法
            tryPresize(n << 1);
            // b 是头结点
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            // 加锁
            synchronized (b) {
                if (tabAt(tab, index) == b) {
                    // 下面就是遍历链表，创建一颗红黑树
                    TreeNode<K, V> hd = null, tl = null;
                    for (Node<K, V> e = b; e != null; e = e.next) {
                        TreeNode<K, V> p =
                                new 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 TreeBin<K, V>(hd));
                }
            }
        }
    }
}

扩容：tryPresize

若是说 Java8 ConcurrentHashMap 的源码不简单，那么说的就是扩容操做和迁移操做。

这个方法要完彻底全看懂还须要看以后的 transfer 方法，读者应该提早知道这点。

这里的扩容也是作翻倍扩容的，扩容后数组容量为原来的 2 倍。

// 首先要说明的是，方法参数 size 传进来的时候就已经翻了倍了
private final void tryPresize(int size) {
    // c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
    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 分支和以前说的初始化数组的代码基本上是同样的，在这里，咱们能够不用管这块代码
        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); // 0.75 * n
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        } else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) {
            // 我没看懂 rs 的真正含义是什么，不过也关系不大
            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;
                // 2. 用 CAS 将 sizeCtl 加 1，而后执行 transfer 方法
                //    此时 nextTab 不为 null
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 1. 将 sizeCtl 设置为 (rs << RESIZE_STAMP_SHIFT) + 2)
            //     我是没看懂这个值真正的意义是什么？不过能够计算出来的是，结果是一个比较大的负数
            //  调用 transfer 方法，此时 nextTab 参数为 null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                    (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

这个方法的核心在于 sizeCtl 值的操做，首先将其设置为一个负数，而后执行 transfer(tab, null)，再下一个循环将 sizeCtl 加 1，并执行 transfer(tab, nt)，以后多是继续 sizeCtl 加 1，并执行 transfer(tab, nt)。

因此，可能的操做就是执行 1 次 transfer(tab, null) + 屡次 transfer(tab, nt)，这里怎么结束循环的须要看完 transfer 源码才清楚。

数据迁移：transfer

下面这个方法很点长，将原来的 tab 数组的元素迁移到新的 nextTab 数组中。

虽然咱们以前说的 tryPresize 方法中屡次调用 transfer 不涉及多线程，可是这个 transfer 方法能够在其余地方被调用，典型地，咱们以前在说 put 方法的时候就说过了，请往上看 put 方法，是否是有个地方调用了 helpTransfer 方法，helpTransfer 方法会调用 transfer 方法的。

此方法支持多线程执行，外围调用此方法的时候，会保证第一个发起数据迁移的线程，nextTab 参数为 null，以后再调用此方法的时候，nextTab 不会为 null。

阅读源码以前，先要理解并发操做的机制。原数组长度为 n，因此咱们有 n 个迁移任务，让每一个线程每次负责一个小任务是最简单的，每作完一个任务再检测是否有其余没作完的任务，帮助迁移就能够了，而 Doug Lea 使用了一个 stride，简单理解就是步长，每一个线程每次负责迁移其中的一部分，如每次迁移 16 个小任务。因此，咱们就须要一个全局的调度者来安排哪一个线程执行哪几个任务，这个就是属性 transferIndex 的做用。

第一个发起数据迁移的线程会将 transferIndex 指向原数组最后的位置，而后从后往前的 stride 个任务属于第一个线程，而后将 transferIndex 指向新的位置，再往前的 stride 个任务属于第二个线程，依此类推。固然，这里说的第二个线程不是真的必定指代了第二个线程，也能够是同一个线程，这个读者应该能理解吧。其实就是将一个大的迁移任务分为了一个个任务包。

private final void transfer(Node<K, V>[] tab, Node<K, V>[] nextTab) {
    int n = tab.length, stride;
    // stride 在单核下直接等于 n，多核模式下为 (n>>>3)/NCPU，最小值是 16
    // stride 能够理解为”步长“，有 n 个位置是须要进行迁移的，
    //   将这 n 个任务分为多个任务包，每一个任务包有 stride 个任务
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range
    // 若是 nextTab 为 null，先进行一次初始化
    //    前面咱们说了，外围会保证第一个发起迁移的线程调用此方法时，参数 nextTab 为 null
    //       以后参与迁移的线程调用此方法时，nextTab 不会为 null
    if (nextTab == null) {
        try {
            // 容量翻倍
            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 是 ConcurrentHashMap 中的属性
        nextTable = nextTab;
        // transferIndex 也是 ConcurrentHashMap 的属性，用于控制迁移的位置
        transferIndex = n;
    }
    int nextn = nextTab.length;
    // ForwardingNode 翻译过来就是正在被迁移的 Node
    // 这个构造方法会生成一个Node，key、value 和 next 都为 null，关键是 hash 为 MOVED
    // 后面咱们会看到，原数组中位置 i 处的节点完成迁移工做后，
    //    就会将位置 i 处设置为这个 ForwardingNode，用来告诉其余线程该位置已经处理过了
    //    因此它其实至关因而一个标志。
    ForwardingNode<K, V> fwd = new ForwardingNode<K, V>(nextTab);
    // advance 指的是作完了一个位置的迁移工做，能够准备作下一个位置的了
    boolean advance = true;
    boolean finishing = false; // to ensure sweep before committing nextTab



    /*

     * 下面这个 for 循环，最难理解的在前面，而要看懂它们，应该先看懂后面的，而后再倒回来看

     *

     */
    // i 是位置索引，bound 是边界，注意是从后往前
    for (int i = 0, bound = 0; ; ) {
        Node<K, V> f;
        int fh;
        // 下面这个 while 真的是很差理解
        // advance 为 true 表示能够进行下一个位置的迁移了
        //   简单理解结局：i 指向了 transferIndex，bound 指向了 transferIndex-stride
        while (advance) {
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
                advance = false;
                // 将 transferIndex 值赋给 nextIndex
                // 这里 transferIndex 一旦小于等于 0，说明原数组的全部位置都有相应的线程去处理了
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
            } else if (U.compareAndSwapInt
                    (this, TRANSFERINDEX, nextIndex,
                            nextBound = (nextIndex > stride ?
                                    nextIndex - stride : 0))) {
                // 看括号中的代码，nextBound 是此次迁移任务的边界，注意，是从后往前
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            if (finishing) {
                // 全部的迁移操做已经完成
                nextTable = null;
                // 将新的 nextTab 赋值给 table 属性，完成迁移
                table = nextTab;
                // 从新计算 sizeCtl：n 是原数组长度，因此 sizeCtl 得出的值将是新数组长度的 0.75 倍
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            // 以前咱们说过，sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2
            // 而后，每有一个线程参与迁移就会将 sizeCtl 加 1，
            // 这里使用 CAS 操做对 sizeCtl 进行减 1，表明作完了属于本身的任务
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                // 任务结束，方法退出
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                // 到这里，说明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT，
                // 也就是说，全部的迁移任务都作完了，也就会进入到上面的 if(finishing){} 分支了
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        // 若是位置 i 处是空的，没有任何节点，那么放入刚刚初始化的 ForwardingNode ”空节点“
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
            // 该位置处是一个 ForwardingNode，表明该位置已经迁移过了
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            // 对数组该位置处的结点加锁，开始处理数组该位置处的迁移工做
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K, V> ln, hn;
                    // 头结点的 hash 大于 0，说明是链表的 Node 节点
                    if (fh >= 0) {
                        // 下面这一块和 Java7 中的 ConcurrentHashMap 迁移是差很少的，
                        // 须要将链表一分为二，
                        //   找到原链表中的 lastRun，而后 lastRun 及其以后的节点是一块儿进行迁移的
                        //   lastRun 以前的节点须要进行克隆，而后分到两个链表中
                        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);
                        }
                        // 其中的一个链表放在新数组的位置 i
                        setTabAt(nextTab, i, ln);
                        // 另外一个链表放在新数组的位置 i+n
                        setTabAt(nextTab, i + n, hn);
                        // 将原数组该位置处设置为 fwd，表明该位置已经处理完毕，
                        //    其余线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了
                        setTabAt(tab, i, fwd);
                        // advance 设置为 true，表明该位置已经迁移完毕
                        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;
                            }
                        }
                        // 若是一分为二后，节点数少于 8，那么将红黑树转换回链表
                        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;
                        // 将 ln 放置在新数组的位置 i
                        setTabAt(nextTab, i, ln);
                        // 将 hn 放置在新数组的位置 i+n
                        setTabAt(nextTab, i + n, hn);
                        // 将原数组该位置处设置为 fwd，表明该位置已经处理完毕，
                        //    其余线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了
                        setTabAt(tab, i, fwd);
                        // advance 设置为 true，表明该位置已经迁移完毕
                        advance = true;
                    }
                }
            }
        }
    }
}

说到底，transfer 这个方法并无实现全部的迁移任务，每次调用这个方法只实现了 transferIndex 往前 stride 个位置的迁移工做，其余的须要由外围来控制。

这个时候，再回去仔细看 tryPresize 方法可能就会更加清晰一些了。

get 过程分析

get 方法历来都是最简单的，这里也不例外：

1. 计算 hash 值

2. 根据 hash 值找到数组对应位置: (n – 1) & h

3. 根据该位置处结点性质进行相应查找

• 若是该位置为 null，那么直接返回 null 就能够了

• 若是该位置处的节点恰好就是咱们须要的，返回该节点的值便可

• 若是该位置节点的 hash 值小于 0，说明正在扩容，或者是红黑树，后面咱们再介绍 find 方法

若是以上 3 条都不知足，那就是链表，进行遍历比对便可

public V get(Object key) {
    Node<K, V>[] tab;
    Node<K, V> e, p;
    int n, eh;
    K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
        // 判断头结点是否就是咱们须要的节点
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 若是头结点的 hash 小于 0，说明 正在扩容，或者该位置是红黑树
        else if (eh < 0)
            // 参考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 遍历链表
        while ((e = e.next) != null) {
            if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

简单说一句，此方法的大部份内容都很简单，只有正好碰到扩容的状况，ForwardingNode.find(int h, Object k) 稍微复杂一些，不过在了解了数据迁移的过程后，这个也就不难了，因此限于篇幅这里也不展开说了。

总结

其实也不是很难嘛，虽然没有像以前的 AQS 和线程池同样一行一行源码进行分析，但仍是把全部初学者可能会糊涂的地方都进行了深刻的介绍，只要是稍微有点基础的读者，应该是很容易就能看懂 HashMap 和 ConcurrentHashMap 源码了。

看源码不算是目的吧，深刻地了解 Doug Lea 的设计思路，我以为还挺有趣的，大师就是大师，代码写得真的是好啊。