ConcurrentHashMap的put方法源码级分析

之前被面试官问到，

如果ConcurrentHashMap的CAS操作失败时会怎么做呢？

当时并没有阅读过ConcurrentHashMap的源码，仅仅停留在使用上，因此这个问题回答的很不好，今天记录一下。

 

首先看到ConcurrentHashMap的put方法是长这样的。

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

很显然，它调用了一个putVal方法，接着往下看。我这里直接把整个方法贴过来，然后在一步步分析，以便于我们对这个方法有一个整体印象。

/** Implementation for put and putIfAbsent */
    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();
            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
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        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;
                                }
                            }
                        }
                        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;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

从第一个条件判断就能看出来，在put方法中，key和value是不允许为null的，如果为null将会直接抛出异常。

if (key == null || value == null) throw new NullPointerException();

第二步就是计算hash值了。

    int hash = spread(key.hashCode());

    static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }

第三，进入一个死循环。

        for (Node<K,V>[] tab = table;;) 

然后就会判断这个HashMap是不是空的，也就是判断是不是第一次加载，这里用到了延迟加载的方式。具体的初始化逻辑大家感兴趣可以自己去看看。

            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();

第四步，初始化完成之后，就会根据根据其hash值找到对应下标的节点，如果该节点为空，那么就执行CAS插入操作了。这里的第三个参数设置为null表示CAS操作的预期值是null。如果插入成功，则直接break，结束整个方法并返回null。

            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
            }

如果发现正在执行扩容操作，那么就协助扩容并取得扩容后的tab，然后重新开始一个循环。

具体的扩容操作大家感兴趣可以自己去看。

            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);

到这里，终于进入新的阶段了。使用synchronized关键字给链表的头节点加锁，此时其它想要put到同一个链表的操作应被阻塞在这里。如果发现上锁之后的头节点和一开始得到的头节点不同，证明其发生了改变，此时binCount的值仍然是0，并不会进入binCount那个条件判断。

此时已经执行完那个for循环的全部内容了，直接重新开启一个循环，再来一遍上述流程（得亏电脑不是人，不然绝对疯掉）。

                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {...}
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }

好了，这一次f没有发生改变，在这里打一个分支的标记。fh>=0则表示是链表结构的，否则表示是红黑树结构的。

if (fh >= 0) {...}
else if (f instanceof TreeBin) {...}

先看链表结构的。

先将binCount标志为1，从前面的if已经可以判断出，binCount不是0了，可以回头看看第四步的判断。

这里的外层if判断的是key是否发生重复，如果发生重复了，那么执行值覆盖，并且返回旧值。

onlyIfAbsent在put方法时已经设置为情况下为false。

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

如果不满足上面这个if，则会判断是否走到链表的末尾，如果已经走到链表的末尾，那么就执行插入操作。否则继续循环这个链表。

                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }

链表的情况下，操作已经完成，如果是树的话就执行树的操作。

                            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>=TREEIFY_THRESHOLD（默认是8）则会转换为树。

如果旧值不为null，那么put方法就会返回被覆盖的旧值。

为什么要早早的return oldVal？如果有oldVal，显然就不需要扩容了，因为执行的是覆盖，而非加入。

                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }

最后需要进行扩容判断。

addCount(1L, binCount);

 

所以最后回答一下一开始提出的问题，ConcurrentHashMap的CAS操作失败时会不停地重试，直到put方法成功或是出现异常。