ConcurrentHashMap源码分析（三）

第二篇分析了添加元素的方法，添加元素是可能会进行链表转树的动作，第三篇来分析下删除元素的方法。

方法

remove 删除元素

    public V remove(Object key) {
        return replaceNode(key, null, null);
    }
	
    /**
     * Implementation for the four public remove/replace methods:
     * Replaces node value with v, conditional upon match of cv if
     * non-null.  If resulting value is null, delete.
     */
    final V replaceNode(Object key, V value, Object cv) {
        // 计算hash
        int hash = spread(key.hashCode());
        // 死循环遍历node数组
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)
                // 如果循环到节点所在的桶不存在，就跳出循环
                break;
            else if ((fh = f.hash) == MOVED)
                // 如果循环到的桶第一元素的hash是MOVED,说明正在扩容，当前线程协助扩容
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                // 锁住当前的桶，分段锁
                synchronized (f) {
                    // 判断桶第一个元素是不是f，也就是判断了一下第一个元素有没有被修改过
                    if (tabAt(tab, i) == f) {
                        // 判断fh>=0,也就是链表的节点
                        if (fh >= 0) {
                            // 标志置为true
                            validated = true;
                            // 死循环遍历，找到目标key的元素
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    // 找到了目标元素
                                    // 先缓存下目标节点的value
                                    V ev = e.val;
                                    // 判断旧值是否等于cv
                                    if (cv == null || cv == ev ||
                                        (ev != null && cv.equals(ev))) {
                                        // 缓存下ev
                                        oldVal = ev;
                                        // 如果旧值不为空
                                        if (value != null)
                                            // 传入的新值替换节点中的旧值
                                            e.val = value;
                                        else if (pred != null)
                                            // 如果pred不为空
                                            // 把当前节点的next赋值给pred(当前节点的上一个节点)的next
                                            // 也就是删除了当前节点
                                            pred.next = e.next;
                                        else
                                            // 如果pred为空，说明当前节点是第一个节点，删除掉
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                // 循环快结束了，把当前节点给pred
                                pred = e;
                                // 遍历到链表尾部，仍然没找到目标元素，跳出循环
                                if ((e = e.next) == null)
                                    break;
                            }
                        }
                        else if (f instanceof TreeBin) {
                            // 如果是树节点
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            // 找到目标节点
                            if ((r = t.root) != null &&
                                (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                // 判读目标节点的value是否等于cv
                                if (cv == null || cv == pv ||
                                    (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    // 如果value不是空，就替换掉旧值
                                    if (value != null)
                                        p.val = value;
                                    // 否则删除元素
                                    else if (t.removeTreeNode(p))
                                        // 如果删除后元素个数少至6以下，树转链表
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                // 如果处理过，不论有没有找到元素都返回
                if (validated) {
                    // 如果旧值不是null,也就是找到了元素，返回旧值
                    if (oldVal != null) {
                        if (value == null)
                            // 如果value为空，元素个数减一
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        // 没有找到元素返回空
        return null;
    }

转载于:https://my.oschina.net/u/3295680/blog/3075523