ConcurrentHashMap源码分析(保姆式讲解)：Put、扩容原理详解 博主可答疑

一、前言：为什么要有ConcurrentHashMap

  我们用HashMap不香吗？感觉什么都能干！但是呢。。。   在多个线程同时使用HashMap的时候可能就会出错，你不信可以试试用Put方法，可能你20调线程Put20个不同的值，你会发现最后map中没有20个K-V对。因为比如其中两个线程插入的值所算出的哈希值是一样，所以他们是插入同一个下标。那么开始展现真是的技术了！

  

 

  线程不安全：两个线程的put举例

  现在有两个线程，一个叫大哈，一个叫二哈，他们两个手里都有一个数，大哈拿着A，二哈拿着B。

这两兄弟很有缘。都要把A,B数放入同一个地方，2号位置。

 

先是大哈进入看见没有数(正准备放入的时候，他的线程时间片到了，切到了二哈线程去了)，红字非常重要，我们可以把大哈当作瞎子(现在记忆中2号位置是没有数的)

然后二哈线程很顺利的把B放入了这个地方

二哈放了B就走了，现在大哈线程醒了，然后因为大哈记忆中2号位置是没有存数的，所以直接把自己的A放入，把B覆盖了。而不是加一个链表，掉在B后面！！

这种情况是不对的情况。

我们真实正确的情况是这样。

所以是HashMap是不安全的。 如果用concurrentHashMap的话，我们就能得到上图的正确结果

二、源码分析

1、ConcurrentHashMap的put方法

 

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) {
//判断key的hash散列表处是否有位置
            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;
}

 

 初始化initTable()

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
//sizeCtl在两个HashMap的比较中有
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
//yield，到了它的线程，主动让权，
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
//SIZECTL直接从内存获取当前这个属性字段的在整个对象空间里的偏移量
//compareAndSwapInt  比较SIZECTL和sc比较，相等就将-1赋给iszeCtl，如果还有其他并发操作，会回到上一sc=sizeCtl<0，会让权cpu(去执行完初始化后，才能跑下走)
            try {
                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);
//转化成为table的阈值
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

扩容函数  addCount(1L, binCount)

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
//看是否当前的数组长度是否大于等于阈值sc
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
//判断是否能扩容不
                transfer(tab, null);
//正儿八经开始扩容
            s = sumCount();
        }
    }
}

  transfer函数里有这段代码：

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)
//NCPU根据电脑来的，四核八线程NCPU就是8，如果数量超过16就分段去迁移桶，如果小于就直接用单线程，MIN_TRANSFER_STRIDE=16
        stride = MIN_TRANSFER_STRIDE; // subdivide range
    if (nextTab == null) {            // initiating
        try {
            @SuppressWarnings("unchecked")
            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 = nextTab;
        transferIndex = n;
//记录扩容前的大小，以便后面往前遍历。如果从0开始的话，每次都扩容n遍历时这个n值每次都变，所以直接从后往前遍历到0即可，程序复用性高。
    }
    int nextn = nextTab.length;
    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;;) {
//for是个死循环里面肯定有中止结束标志，
        Node<K,V> f; int fh;
        while (advance) {
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
//最大--i与最小值下标bound比较
                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;
//表示最大下标，从最大坐标依次i--，迁移
                advance = false;
            }
        }
        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; // recheck before commit
            }
        }
        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) {
//fh当前节点存在的哈希值
                        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;
//最后同色的节点：lastrun
                            }
                        }
                        if (runBit == 0) {
                            ln = lastRun;
//低位链表扩容放0颜色块的数据包
                            hn = null;
//高位链表扩容放1颜色块的数据包
                        }
                        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);
//将高位链表放入总链表
                        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;
                    }
                }
            }
        }
    }
}

 

扩容要做的事情：

1.创建新的数组

2.转移旧的数组到新的数组中去（怎么计算位置?） ，前提都是以2的N次幂，方便迁移

 h&(n-1):计算下标的位置

 h&31（16扩容成32）

31占用5个二进制位来存储

旧数组的时候占用4个二进制位来存储

 

1111 0010 1110 1101     13

1010 0101 1101 1101      29

1100 0101 1100 1101      13

如果存储到16个长度的数组中，下标是否一致？（取高位和hash异或，是为了得到新哈希）

一样，只看后四位即可

如果存储到32个长度的数组中，下标还一样吗？

只需要看后5位即可，但是有没有更加的算法？

如果第五位等于0，表示跟原数组位置一定

如果第五位等于1，表示在原数组位置的基础上加上 原数组的整体长度即可。

lastrun 代表什么：同色元素的最后位置，因为最后的同色元素后面的元素都一样的，直接迁移过去即可，因为拿整数来说，越在后面数越到那么判断位更容易为1，也不一定毕竟之前是取模。

 

 

 

 

多线程扩容 ：原来数组长度是128，扩容后是256，难道需要用单线程去完成整体全部元素的迁移工作吗？

多线程方式运行，数据不能乱，此时怎么做？

将原来的数组分段规定每个线程最少负责16个桶的迁移工作，8个线程可以并行，小于16个桶，那么直接使用单线程运行即可

 

 

三、HashMap 传送点

https://blog.csdn.net/qq_40262372/article/details/112669338

 

四、高效刷题步骤及试题汇总：

https://blog.csdn.net/qq_40262372/article/details/112556249

 

五、如有疑问可加QQ群讨论：725936761     博主免费答疑
欢迎大家一起讨论进步。