ConcurrentHashMap学习

TaoCoding

已于 2024-08-28 17:22:05 修改

阅读量91

点赞数 1

文章标签：学习 java

于 2023-04-13 14:45:19 首次发布

本文链接：https://blog.csdn.net/qq_58764158/article/details/130130200

版权

transfer 扩容

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    //stride 表示一个线程需要处理的桶的数量，最小值MIN_TRANSFER_STRIDE 为 16
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; 
    if (nextTab == null) {            // 初始化新的散列表，只有第一个扩容的线程来时，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; //！！！！sizeCtl 是一个非常重要的参数，在扩容时，该值会被第一个进入扩容的线程设置为负数，用来标记正在扩容
            return;
        }
        nextTable = nextTab;
        transferIndex = n;  
    }
    //开始扩容
    int nextn = nextTab.length;
    //标记作用，hash值为-1，当一个桶迁移完毕时，会将头节点设置为ForwardingNode，告诉线程该桶已经迁移完毕
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    boolean advance = true;
    boolean finishing = false; // to ensure sweep before committing nextTab
    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))) {
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        //扩容结束
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            //收尾操作，将nextTable设为null，table指向nextTab，更新扩容阈值：n为原来容量， (n << 1) - (n >>> 1) = 2 * n - n / 2 = 1.5 * n = 2n * 0.75
            if (finishing) {
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            //扩容即将结束，将sizeCtl-1 (每进来一个线程进行扩容，都会将 sizeCtl + 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
            }
        }
        else if ((f = tabAt(tab, i)) == null)//若该桶里没有元素，说明已经处理完毕，则放入一个标志节点ForwardingNode
            advance = casTabAt(tab, i, null, fwd);
        else if ((fh = f.hash) == MOVED)//MOVED == -1，hash值为-1，说明是一个ForwardingNode节点，不再处理
            advance = true; // already processed
        else {//到这说明该桶尚未处理
            synchronized (f) {
                if (tabAt(tab, i) == f) {//判断一下是否其他线程已经将该桶处理完毕 
                    Node<K,V> ln, hn;
                    if (fh >= 0) { //hash >= 0 说明是链表节点
                        //runBit用来记录链表中最后一个即将迁移位置与前一个节点即将迁移位置不一样的节点，因为桶的位置是通过 hash & （n - 1）运算得来的
                        //当n为16时， n - 1 = 11110(二进制下)，扩容后 2n - 1 = 11111，hash & 11111 的结果相比 hash & 11110 的结果可能多一个 00001 = n
                        //这样扩容后本来一条链上的节点就有可能分到两个桶下，一个不变，另一个为 i + n
                        int runBit = fh & n; //假设runBit = 0
                        Node<K,V> lastRun = f; //那么lastRun就是记录最后一个桶位置为 i + n 的节点
                        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 { // runBit == 1
                            hn = lastRun; //hn表示高位的节点，也就是桶的位置为i + n
                            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;
                    }
                }
            }
        }
    }
}

总结一下（个人理解)：

在transfer函数里，用sizeCtl标记是否正在扩容，用ForwardingNode（hash == 1）来标记已经处理好的桶，且属性都被voliatile修饰，保证了可见性，再配合cas、synchronized实现原子操作。