从源码看ConcurrentHashMap

谁借莪１个温暖的怀抱￠ 2023-07-18 12:54 12阅读 0赞

简介

ConcurrentHashMap是线程安全的HashMap实现，这里主要研究JDK8后的ConcurrentHashMap，下面是ConcurrentHashMap的简单结构：在这里插入图片描述
ConcurrentHashMap基于HashMap的基本逻辑，通过CAS + synchronized 来保证并发安全性。ConcurrentHashMap使用的数组及数组的每个节点都为volatile类型，通过CAS进行更新删除操作，而所有的链表操作都需要通过synchronized锁定链表的头节点，然后进行操作。

  1. /**
  2.      * The array of bins. Lazily initialized upon first insertion.
  3.      * Size is always a power of two. Accessed directly by iterators.
  4.      */
  5.     transient volatile Node<K,V>[] table;
  7.     /**
  8.      * Key-value entry.  This class is never exported out as a
  9.      * user-mutable Map.Entry (i.e., one supporting setValue; see
  10.      * MapEntry below), but can be used for read-only traversals used
  11.      * in bulk tasks.  Subclasses of Node with a negative hash field
  12.      * are special, and contain null keys and values (but are never
  13.      * exported).  Otherwise, keys and vals are never null.
  14.      */
  15.     static class Node<K,V> implements Map.Entry<K,V> {
  17.         final int hash;
  18.         final K key;
  19.         volatile V val;
  20.         volatile Node<K,V> next;
  21.    }

核心方法

1.put方法

  1. final V putVal(K key, V value, boolean onlyIfAbsent) {
  3.         if (key == null || value == null) throw new NullPointerException();
  4.         int hash = spread(key.hashCode());
  5.         int binCount = 0;
  6.         for (Node<K,V>[] tab = table;;) {
  8.             Node<K,V> f; int n, i, fh;
  9.             if (tab == null || (n = tab.length) == 0)
  10.                 tab = initTable();
  11.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
  13.                 if (casTabAt(tab, i, null,
  14.                              new Node<K,V>(hash, key, value, null)))
  15.                     break;                   // no lock when adding to empty bin
  16.             }
  17.             else if ((fh = f.hash) == MOVED)
  18.                 tab = helpTransfer(tab, f);
  19.             else {
  21.                 V oldVal = null;
  22.                 synchronized (f) {
  24.                     if (tabAt(tab, i) == f) {
  26.                         if (fh >= 0) {
  28.                             binCount = 1;
  29.                             for (Node<K,V> e = f;; ++binCount) {
  31.                                 K ek;
  32.                                 if (e.hash == hash &&
  33.                                     ((ek = e.key) == key ||
  34.                                      (ek != null && key.equals(ek)))) {
  36.                                     oldVal = e.val;
  37.                                     if (!onlyIfAbsent)
  38.                                         e.val = value;
  39.                                     break;
  40.                                 }
  41.                                 Node<K,V> pred = e;
  42.                                 if ((e = e.next) == null) {
  44.                                     pred.next = new Node<K,V>(hash, key,
  45.                                                               value, null);
  46.                                     break;
  47.                                 }
  48.                             }
  49.                         }
  50.                         else if (f instanceof TreeBin) {
  52.                             Node<K,V> p;
  53.                             binCount = 2;
  54.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
  55.                                                            value)) != null) {
  57.                                 oldVal = p.val;
  58.                                 if (!onlyIfAbsent)
  59.                                     p.val = value;
  60.                             }
  61.                         }
  62.                     }
  63.                 }
  64.                 if (binCount != 0) {
  66.                     if (binCount >= TREEIFY_THRESHOLD)
  67.                         treeifyBin(tab, i);
  68.                     if (oldVal != null)
  69.                         return oldVal;
  70.                     break;
  71.                 }
  72.             }
  73.         }
  74.         addCount(1L, binCount);
  75.         return null;
  76.     }

我们可以看到put是通过一个死循环来实现，在循环逻辑内：

  1. 首先检查核心的Node[] table是否已经初始化，如果没有初始化，则利用CAS将sizeCtl的值置为-1进行初始化。
  2. 通过CAS查询key相应的槽位是否为 null，若为null直接通过CAS将键值对放入槽位。
  3. 如果相应的槽位已经有节点，并且其hash值为-1，则表示正在进行扩容，则当前线程帮忙进行扩容。
  4. 否则通过synchronized锁住槽位内的节点即链表的头结点，然后遍历链表，寻找是否有hash值及key值相同的节点，若有则将value设置进去，否者创建新的节点加入链表。
  5. 通过addCount函数更新ConcurrentHashMap键值对的数量。

2.get方法

  1. public V get(Object key) {
  3.         Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
  4.         int h = spread(key.hashCode());
  5.         if ((tab = table) != null && (n = tab.length) > 0 &&
  6.             (e = tabAt(tab, (n - 1) & h)) != null) {
  8.             if ((eh = e.hash) == h) {
  10.                 if ((ek = e.key) == key || (ek != null && key.equals(ek)))
  11.                     return e.val;
  12.             }
  13.             else if (eh < 0)
  14.                 return (p = e.find(h, key)) != null ? p.val : null;
  15.             while ((e = e.next) != null) {
  17.                 if (e.hash == h &&
  18.                     ((ek = e.key) == key || (ek != null && key.equals(ek))))
  19.                     return e.val;
  20.             }
  21.         }
  22.         return null;
  23.     }

get方法实现的逻辑比较简单：

  1. 利用key通过cas的方式获取其对应槽位的节点，若该节点就是想要查询的节点，那就直接返回value。
  2. 如果槽位内节点的hash值小于0则说明正在进行扩容，则通过ForwardingNode的find函数去新的数组nextTable中进行查找。
  3. 以上都不符合的话，就直接遍历节点，匹配就返回，否则最后就返回null。

3.扩容方法

  1. /**
  2.      * Helps transfer if a resize is in progress.
  3.      */
  4.     final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
  6.         Node<K,V>[] nextTab; int sc;
  7.         if (tab != null && (f instanceof ForwardingNode) &&
  8.             (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
  10.             int rs = resizeStamp(tab.length);
  11.             while (nextTab == nextTable && table == tab &&
  12.                    (sc = sizeCtl) < 0) {
  14.                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
  15.                     sc == rs + MAX_RESIZERS || transferIndex <= 0)
  16.                     break;
  17.                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
  19.                     transfer(tab, nextTab);
  20.                     break;
  21.                 }
  22.             }
  23.             return nextTab;
  24.         }
  25.         return table;
  26.     }
  28.     /**
  29.      * Moves and/or copies the nodes in each bin to new table. See
  30.      * above for explanation.
  31.      */
  32.     private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  34.         int n = tab.length, stride;
  35.         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
  36.             stride = MIN_TRANSFER_STRIDE; // subdivide range
  37.         if (nextTab == null) {
  38.                 // initiating
  39.             try {
  41.                 @SuppressWarnings("unchecked")
  42.                 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
  43.                 nextTab = nt;
  44.             } catch (Throwable ex) {
  45.           // try to cope with OOME
  46.                 sizeCtl = Integer.MAX_VALUE;
  47.                 return;
  48.             }
  49.             nextTable = nextTab;
  50.             transferIndex = n;
  51.         }
  52.         int nextn = nextTab.length;
  53.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  54.         boolean advance = true;
  55.         boolean finishing = false; // to ensure sweep before committing nextTab
  56.         for (int i = 0, bound = 0;;) {
  58.             Node<K,V> f; int fh;
  59.             while (advance) {
  61.                 int nextIndex, nextBound;
  62.                 if (--i >= bound || finishing)
  63.                     advance = false;
  64.                 else if ((nextIndex = transferIndex) <= 0) {
  66.                     i = -1;
  67.                     advance = false;
  68.                 }
  69.                 else if (U.compareAndSwapInt
  70.                          (this, TRANSFERINDEX, nextIndex,
  71.                           nextBound = (nextIndex > stride ?
  72.                                        nextIndex - stride : 0))) {
  74.                     bound = nextBound;
  75.                     i = nextIndex - 1;
  76.                     advance = false;
  77.                 }
  78.             }
  79.             if (i < 0 || i >= n || i + n >= nextn) {
  81.                 int sc;
  82.                 if (finishing) {
  84.                     nextTable = null;
  85.                     table = nextTab;
  86.                     sizeCtl = (n << 1) - (n >>> 1);
  87.                     return;
  88.                 }
  89.                 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
  91.                     if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
  92.                         return;
  93.                     finishing = advance = true;
  94.                     i = n; // recheck before commit
  95.                 }
  96.             }
  97.             else if ((f = tabAt(tab, i)) == null)
  98.                 advance = casTabAt(tab, i, null, fwd);
  99.             else if ((fh = f.hash) == MOVED)
  100.                 advance = true; // already processed
  101.             else {
  103.                 synchronized (f) {
  105.                     if (tabAt(tab, i) == f) {
  107.                         Node<K,V> ln, hn;
  108.                         if (fh >= 0) {
  110.                             int runBit = fh & n;
  111.                             Node<K,V> lastRun = f;
  112.                             for (Node<K,V> p = f.next; p != null; p = p.next) {
  114.                                 int b = p.hash & n;
  115.                                 if (b != runBit) {
  117.                                     runBit = b;
  118.                                     lastRun = p;
  119.                                 }
  120.                             }
  121.                             if (runBit == 0) {
  123.                                 ln = lastRun;
  124.                                 hn = null;
  125.                             }
  126.                             else {
  128.                                 hn = lastRun;
  129.                                 ln = null;
  130.                             }
  131.                             for (Node<K,V> p = f; p != lastRun; p = p.next) {
  133.                                 int ph = p.hash; K pk = p.key; V pv = p.val;
  134.                                 if ((ph & n) == 0)
  135.                                     ln = new Node<K,V>(ph, pk, pv, ln);
  136.                                 else
  137.                                     hn = new Node<K,V>(ph, pk, pv, hn);
  138.                             }
  139.                             setTabAt(nextTab, i, ln);
  140.                             setTabAt(nextTab, i + n, hn);
  141.                             setTabAt(tab, i, fwd);
  142.                             advance = true;
  143.                         }
  144.                         else if (f instanceof TreeBin) {
  146.                             TreeBin<K,V> t = (TreeBin<K,V>)f;
  147.                             TreeNode<K,V> lo = null, loTail = null;
  148.                             TreeNode<K,V> hi = null, hiTail = null;
  149.                             int lc = 0, hc = 0;
  150.                             for (Node<K,V> e = t.first; e != null; e = e.next) {
  152.                                 int h = e.hash;
  153.                                 TreeNode<K,V> p = new TreeNode<K,V>
  154.                                     (h, e.key, e.val, null, null);
  155.                                 if ((h & n) == 0) {
  157.                                     if ((p.prev = loTail) == null)
  158.                                         lo = p;
  159.                                     else
  160.                                         loTail.next = p;
  161.                                     loTail = p;
  162.                                     ++lc;
  163.                                 }
  164.                                 else {
  166.                                     if ((p.prev = hiTail) == null)
  167.                                         hi = p;
  168.                                     else
  169.                                         hiTail.next = p;
  170.                                     hiTail = p;
  171.                                     ++hc;
  172.                                 }
  173.                             }
  174.                             ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
  175.                                 (hc != 0) ? new TreeBin<K,V>(lo) : t;
  176.                             hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
  177.                                 (lc != 0) ? new TreeBin<K,V>(hi) : t;
  178.                             setTabAt(nextTab, i, ln);
  179.                             setTabAt(nextTab, i + n, hn);
  180.                             setTabAt(tab, i, fwd);
  181.                             advance = true;
  182.                         }
  183.                     }
  184.                 }
  185.             }
  186.         }
  187.     }

扩容的逻辑比较复杂，如果扩容时有多个线程，那么每个线程都可以通过helpTransfer函数帮忙进行扩容：

  1. 首先新建一个两倍长度的数组nextTable。
  2. 初始化ForwardingNode节点，其中保存了新数组nextTable的引用，在处理完每个槽位节点后当做占位节点，表示该槽位已经处理过了。
  3. 通过for循环处理每个槽位中的链表元素，处理完后在这个槽位内通过CAS插入初始化的ForwardingNode节点，用于告诉其它线程该槽位已经处理过了。
  4. 如果某个槽位已经被线程A处理了，那么线程B处理到这个节点时，取到该节点的hash值应该为MOVED，值为-1，则直接跳过，继续处理下一个槽位内的节点。

4.计数方法

  1. /**
  2.      * {@inheritDoc}
  3.      */
  4.     public int size() {
  6.         long n = sumCount();
  7.         return ((n < 0L) ? 0 :
  8.                 (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
  9.                 (int)n);
  10.     }
  12.     /**
  13.      * A padded cell for distributing counts.  Adapted from LongAdder
  14.      * and Striped64.  See their internal docs for explanation.
  15.      */
  16.     @sun.misc.Contended static final class CounterCell {
  18.         volatile long value;
  19.         CounterCell(long x) {
  20.      value = x; }
  21.     }
  23.     final long sumCount() {
  25.         CounterCell[] as = counterCells; CounterCell a;
  26.         long sum = baseCount;
  27.         if (as != null) {
  29.             for (int i = 0; i < as.length; ++i) {
  31.                 if ((a = as[i]) != null)
  32.                     sum += a.value;
  33.             }
  34.         }
  35.         return sum;
  36.     }

代码里的变量baseCount用于在无竞争环境下记录元素的个数，每当插入元素或删除元素时都会利用CAS更新键值对个数。
当有线程竞争时，会使用CounterCell数组来计数，每个ConuterCell都是一个独立的计数单元。线程可以通过ThreadLocalRandom.getProbe() & m找到属于它的CounterCell进行计数。这种方法能够降低线程的竞争，相比所有线程对一个共享变量不停进行CAS操作性能上要好很多。这里的CounterCell数组初始容量为2，最大容量是机器的CPU数。
注意这里有个@sun.misc.Contended，这个注解用于解决伪共享问题。所谓伪共享，就是在同一缓存行cache line（CPU缓存的基本单位）中连续存储了多个变量，当其中一个变量被修改时，会导致其他变量也失效，会降低计算机cache的缓存命中率并且导致内存总线流量大增。

发表评论

表情：
评论列表 （有 0 条评论，12人围观）

还没有评论，来说两句吧...

相关阅读