14.ConcurrentHashMap源码解析

1.架构
ConcurrentHashMap的底层数据结构和方法的实现细节与HashMap大体一致，但两者在类结构上却没有任何关联，看ConcurrentHashMap源码，会发现很多方法的代码和HashMap很相似，那就会存在一个问题，为什么不继承HashMap呢？继承的确是个好办法，但尴尬的是，ConcurrentHashMap都是在方法中间进行一些加锁操作，也就是说加锁把方法切割了，继承就很难解决这个问题。
ConcurrentHashMap和HashMap两者的相同之处主要有两点。一是数组、链表结构几乎相同，所以底层对数据结构的操作思路是相同的(是思路相同，底层实现不同)。二是都实现了Map接口，继承了AbstractMap抽象类，所以大多数的方法也都是相同的，HashMap有的方法，ConcurrentHashMap几乎都有，所以当需要从HashMap切换到ConcurrentHashMap时，无需关心两者之间的兼容问题。
不同之处也有两点。一是红黑树结构略有不同，HashMap的红黑树中的节点叫做 TreeNode，TreeNode不仅仅有属性，还维护着红黑树的结构，比如说查找，新增等等。ConcurrentHashMap中红黑树被拆分成两块，TreeNode仅仅维护着属性和查找功能，新增了TreeBin来维护红黑树结构，并负责根节点的加锁和解锁。二是新增ForwardingNode(转移)节点，扩容时会通过该节点来保障线程安全。

2.类注释

1. 所有的操作都是线程安全的，在使用时，无需再加锁。
2. 多个线程同时进行put、remove等操作时并不会阻塞，可以同时进行，和HashTable不同，HashTable在操作时，会锁住整个Map。
3. 迭代过程中，即使Map结构被修改，也不会抛ConcurrentModificationException异常。
4. 除了数组 + 链表 + 红黑树的基本结构外，新增了转移节点来保证扩容时的线程安全。
5. 提供了很多Stream流式方法，如forEach、search、reduce等。

3.put
ConcurrentHashMap在put方法上的整体思路和HashMap相同，但在线程安全方面写了很多保障的代码，具体源码如下所示。

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
    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 (ConcurrentHashMap.Node<K, V>[] tab = table; ; ) {
            ConcurrentHashMap.Node<K, V> f;
            int n, i, fh;
            //如果tab为空，则进行初始化
            if (tab == null || (n = tab.length) == 0){
                tab = initTable();
            //如果当前索引位置没有值，则直接创建
            }else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //cas在i位置创建新的元素，当i位置为空，即创建成功，结束for循环，否则继续自旋
                if (casTabAt(tab, i, null, new ConcurrentHashMap.Node<K, V>(hash, key, value, null)))
                    break; 
            //如果当前槽点是转移节点，表示该槽点正在扩容，就会一直等待扩容完成
            //转移节点的hash值是固定的，都是MOVED                  
            }else if ((fh = f.hash) == MOVED){
                tab = helpTransfer(tab, f);
            }else { //槽点上有值
                V oldVal = null;
                //锁定当前槽点，其余线程不能操作，保证了线程安全
                synchronized (f) {
                    //这里再次判断i索引位置的数据是否被修改
                    if (tabAt(tab, i) == f) {
                        //链表
                        if (fh >= 0) {
                            //binCount被赋值的话，说明走到了修改表的过程里
                            binCount = 1;
                            for (ConcurrentHashMap.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;
                                }
                                ConcurrentHashMap.Node<K, V> pred = e;
                                //把新增的元素赋值到链表的最后，退出自旋
                                if ((e = e.next) == null) {
                                    pred.next = new ConcurrentHashMap.Node<K, V>(hash, key, value, null);
                                    break;
                                }
                            }
                        //红黑树，这里没有使用TreeNode，使用的是TreeBin，TreeNode只是红黑树的一个节点
                        //TreeBin持有红黑树的引用，并且会对其加锁，保证操作是线程安全的
                        } else if (f instanceof ConcurrentHashMap.TreeBin) {
                            ConcurrentHashMap.Node<K, V> p;
                            binCount = 2;
                            //if条件满足的话，把老的值赋给oldVal
                            //在putTreeVal方法里，在给红黑树重新着色旋转时，会锁住红黑树的根节点
                            if ((p = ((ConcurrentHashMap.TreeBin<K, V>) f).putTreeVal(hash, key, value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent){
                                    p.val = value;
                                }
                            }
                        }
                    }
                }
                //binCount不为空，并且oldVal有值的情况，说明已经新增成功了
                if (binCount != 0) {
                    //链表是否需要转化成红黑树
                    if (binCount >= TREEIFY_THRESHOLD){
                        treeifyBin(tab, i);
                    }
                    if (oldVal != null){
                        return oldVal;
                    }
                    //这一步几乎走不到，槽点已经上锁，只有在红黑树或者链表新增失败时，才会走到这里，两者新增都是自旋的，几乎不会失败
                    break;
                }
            }
        }
        //check容器是否需要扩容，如果需要扩容，调用transfer方法扩容，如果已经在扩容中，check有无完成
        addCount(1L, binCount);
        return null;
    }
}

4.get
ConcurrentHashMap获取value时，先获取数组的下标，然后通过判断数组下标的key是否和搜索的key相等，相等的话直接返回，如果下标的槽点是链表或红黑树的话，分别调用相应查找数据的方法，整体思路和HashMap很像，具体源码如下所示。

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
    public V get(Object key) {
        Node<K, V>[] tab;
        Node<K, V> e, p;
        int n, eh;
        K ek;
        //计算hashcode
        int h = spread(key.hashCode());
        //数组不为空并且当前索引的槽点数据不为空
        if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
            //槽点第一个值和key相等，直接返回
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            //如果是红黑树或者转移节点，使用对应的find方法
            } else if (eh < 0){
                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;
    }
}

5.数组初始化时的线程安全
数组初始化时，首先通过自旋来保证一定可以初始化成功，然后通过CAS设置SIZECTL变量的值，来保证同一时刻只能有一个线程对数组进行初始化，CAS成功之后，还会再次判断当前数组是否已经初始化完成，如果已经初始化完成，就不会再次初始化，通过自旋 + CAS + 双重check等手段保证了数组初始化时的线程安全，具体源码如下所示。

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
    //初始化tab，通过对sizeCtl的变量赋值来保证数组只能被初始化一次
    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        //通过自旋保证初始化成功
        while ((tab = table) == null || tab.length == 0) {
            //小于0代表有线程正在初始化，释放当前CPU的调度权，重新发起锁的竞争
            if ((sc = sizeCtl) < 0){
                Thread.yield();
            //CAS赋值保证当前只有一个线程在初始化，-1代表当前只有一个线程能初始化
            //这种方式保证了数组的初始化的安全性
            }else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    //很有可能执行到这里的时候，tab已经不为空了，这里是双重check
                    if ((tab = table) == null || tab.length == 0) {
                        //进行初始化
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }
}

6.新增槽点值时的线程安全
为了保证线程安全，ConcurrentHashMap做了四处优化，具体如下。

1. 通过自旋死循环保证一定可以新增成功。在新增之前，通过for(Node<K,V> [] tab = table;;)这样的死循环来保证新增一定可以成功，一旦新增成功，就可以退出当前死循环，新增失败的话，会重复新增的步骤，直到新增成功为止。
2. 当前槽点为空时，通过CAS新增。这里的写法非常严谨，没有在判断槽点为空的情况下直接赋值，因为在判断槽点为空和赋值的瞬间，很有可能槽点已经被其他线程赋值了，所以采用CAS算法，能够保证槽点为空的情况下赋值成功，如果恰好槽点已经被其他线程赋值，当前CAS操作失败，会再次执行for自旋，再走槽点有值的put流程，这里就是自旋 + CAS的结合。
3. 当前槽点有值，锁住当前槽点。put时，如果当前槽点有值，就是key的hash冲突的情况，此时槽点上可能是链表或红黑树，通过锁住槽点，来保证同一时刻只会有一个线程能对槽点进行修改。
4. 红黑树旋转时，锁住红黑树的根节点，保证同一时刻，当前红黑树只能被一个线程旋转。

通过以上4点，保证了在各种情况下的新增(不考虑扩容的情况下)，都是线程安全的，通过自旋 + CAS + 锁三大姿势，实现的很巧妙，值得借鉴。

7.扩容时的线程安全
ConcurrentHashMap的扩容时机和HashMap相同，都是在put方法的最后一步检查是否需要扩容，如果需要则进行扩容，但两者扩容的过程完全不同，ConcurrentHashMap扩容的方法叫做transfer，从put方法的addCount方法进去，就能找到transfer方法，transfer方法的主要思路如下。
首先需要把老数组的值全部拷贝到扩容之后的新数组上，先从数组的队尾开始拷贝。然后拷贝数组的槽点，先把原数组槽点锁住，保证原数组槽点不能操作，成功拷贝到新数组时，再把原数组槽点赋值为转移节点。接下来，如果有新数据正好需要put到此槽点，发现槽点为转移节点就会一直等待，所以在扩容完成之前，该槽点对应的数据是不会发生变化的。最后从数组的尾部拷贝到头部，每拷贝成功一次，就把原数组中的节点设置成转移节点。直到所有数组数据都拷贝到新数组后，直接把新数组整个赋值给数组容器，拷贝完成，具体源码如下所示。

/**
 1. 扩容主要分2步，第一步新建新的空数组，第二步移动拷贝每个元素到新数组中去
 2. tab为原数组，nextTab为新数组
 */
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
  private final void transfer(Node<K, V>[] tab, Node<K, V>[] nextTab) {
    //老数组的长度
    int n = tab.length, stride;
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE){
        stride = MIN_TRANSFER_STRIDE; 
    }
    //如果新数组为空，则进行初始化，大小为原数组的两倍，n << 1
    if (nextTab == null) {            
        try {
            @SuppressWarnings("unchecked")
            Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {      
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        nextTable = nextTab;
        transferIndex = n;
    }
    //新数组的长度
    int nextn = nextTab.length;
    //代表转移节点，如果原数组上是转移节点，说明该节点正在被扩容
    ForwardingNode<K, V> fwd = new ForwardingNode<K, V>(nextTab);
    boolean advance = true;
    boolean finishing = false; 
    //无限自旋，i的值会从原数组的最大值开始，慢慢递减到0
    for (int i = 0, bound = 0; ; ) {
        Node<K, V> f;
        int fh;
        while (advance) {
            int nextIndex, nextBound;
            //结束循环的标志
            if (--i >= bound || finishing) {
                advance = false;
            } else if ((nextIndex = transferIndex) <= 0) {//已经拷贝完成
                i = -1;
                advance = false;
            } else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {//每次减少i的值
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        //if任意条件满足，说明拷贝结束了
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            //拷贝结束，直接赋值，因为每次拷贝完一个节点，都在原数组上放转移节点，所以拷贝完成的节点的数据一定不会再发生变化
                //原数组发现是转移节点，便停止操作，会一直等待转移节点消失之后再进行操作，也就是说数组节点一旦被标记为转移节点，是不会再发生任何变动的，所以不会有任何线程安全的问题
              //所以此处直接赋值，没有任何问题
            if (finishing) {
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) 
                    return;
                finishing = advance = true;
                i = n; 
            }
        } else if ((f = tabAt(tab, i)) == null){
            advance = casTabAt(tab, i, null, fwd);
        } else if ((fh = f.hash) == MOVED) {
            advance = true; // already processed
        } 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);
                        //在老数组位置上放上ForwardingNode节点
                            //put时，发现是ForwardingNode节点，就不会再更改这个节点的数据
                        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);
                        //在老数组位置上放上ForwardingNode节点
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                }
            }
        }
    }
  }
}

扩容方法还是很有意思的，通过在原数组上设置转移节点，put时碰到转移节点就会等待，扩容成功之后才能put，这保证了整个扩容过程中肯定是线程安全的，因为数组的槽点一旦被设置成转移节点，在没有扩容完成之前，是无法进行操作的。扩容中的关键点，就是如何保证是线程安全的，总结如下。

1. 拷贝槽点时，会把原数组的槽点锁住。
2. 拷贝成功之后，会把原数组的槽点设置成转移节点，这样如果有数据需要put到该节点时，发现该槽点是转移节点，会一直等待，直到扩容成功之后，才能继续put，可以参考put方法中helpTransfer方法。
3. 从尾到头进行拷贝，拷贝成功就把原数组的槽点设置成转移节点。等扩容拷贝都完成之后，直接把新数组的值赋值给数组容器，之前等待put的数据才能继续put。