ConcurrentHashmap源码好好给你说明白

这个ConcurrentHashmap的设计非常精妙，如果有疑问的地方，欢迎大家在评论区进行激烈讨论！

一、静态工具方法

 private static final int tableSizeFor(int c) {
         int n = c - 1;
         n |= n >>> 1;
         n |= n >>> 2;
         n |= n >>> 4;
         n |= n >>> 8;
         n |= n >>> 16;
         return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
     }

此方法是对给定的int型数据c,返回一个值（比如叫x），则x满足x >=c且x是2的整数次幂。

首先为什么先将c-1，我们等下再说，先解释下从代码第3行到第7行的意思，第三行的意思是先将n与n无符号右移1位后的值做“或”运算，然后将值再赋给n，之后的以此类推。

为什么最后只到了右移16位呢？因为int数据在内存中只有32位。经过这一系列操作，就保证了n的二进制表示中将第一个出现1的位置的后面全部设置为1。然后再返回n+1就保证了

大于c并且是2的整数次幂。然后再解释下为什么开头先将c减去1，因为如果c本来就是2的m次幂的话，我们使用同样的方法最后会得到2的m+1次幂的结果。

二、初始化table：

 private final Node<K,V>[] initTable() {
         Node<K,V>[] tab; int sc;
         while ((tab = table) == null || tab.length == 0) {
             if ((sc = sizeCtl) < 0)
                 Thread.yield(); // lost initialization race; just spin
             else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                 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);
                     }
                 } finally {
                     sizeCtl = sc;
                 }
                 break;
             }
         }
         return tab;
     }

当多个线程同事执行第6行时，只会有一个返回true。compareAndSwapInt方法会将堆上的字段sizeCtl改为-1.这样其他线程会继续在while循环中一直处于第4行的判断内。直到线程将使用sizeCtl将table初始化完。在初始化table后，sizeCtl会修改为下次需要扩容的阈值，即table容量乘以负载因子（n*0.75），这里使用位移的方法（如第13行）。从这里可以看出，其实这个负载因子是固定不变的。构造函数中的loadFactor，仅仅影响table初始化的容量：

 public ConcurrentHashMap(int initialCapacity,
                              float loadFactor, int concurrencyLevel) {
         if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
             throw new IllegalArgumentException();
         if (initialCapacity < concurrencyLevel)   // Use at least as many bins
             initialCapacity = concurrencyLevel;   // as estimated threads
         long size = (long)(1.0 + (long)initialCapacity / loadFactor);
         int cap = (size >= (long)MAXIMUM_CAPACITY) ?
             MAXIMUM_CAPACITY : tableSizeFor((int)size);
         this.sizeCtl = cap;
     }

三、新增数据（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) {
                 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;
     }

方法的主要逻辑是：在key和数组长度计算出的值来确定在数组中插入的位置，如果此位置原来没有节点则构造一个节点插入该位置，如果以前有节点，则在节点所在的链表添加新的节点，如果此位置的节点是一颗树，则在树上添加新的节点。如果插入后的节点数量大于TREEIFY_THRESHOLD，则将该节点转化为树形结构。（该树为一颗红黑树）。其中第15行方法helpTransfer，第54行treeifyBin和第61行addCount方法，将会在后面进行说明。值得注意的是：在方法treefyBin中，会判断如果table的长度小于MIN_TREEIFY_CAPACITY的话，则不会将节点构造成树，而是将table扩容。

四、树化

 private final void treeifyBin(Node<K,V>[] tab, int index) {
         Node<K,V> b; int n, sc;
         if (tab != null) {
             if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                 tryPresize(n << 1);
             else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                 synchronized (b) {
                     if (tabAt(tab, index) == b) {
                         TreeNode<K,V> hd = null, tl = null;
                         for (Node<K,V> e = b; e != null; e = e.next) {
                             TreeNode<K,V> p =
                                 new TreeNode<K,V>(e.hash, e.key, e.val,
                                                   null, null);
                             if ((p.prev = tl) == null)
                                 hd = p;
                             else
                                 tl.next = p;
                             tl = p;
                         }
                         setTabAt(tab, index, new TreeBin<K,V>(hd));
                     }
                 }
             }
         }
     }

真正的树化动作是在第20行的new TreeBin<K,V>（hd）此构造方法中进行的。其中TreeBin类是一个红黑树结构。

五、扩容方法（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)
             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;
         }
         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;;) {
             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;
                 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) {
                             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;
                                 }
                             }
                             if (runBit == 0) {
                                 ln = lastRun;
                                 hn = null;
                             }
                             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.如果nextTable为null则初始化一个。（容量为以前的2倍）

2.然后将table中的节点按MIN_TRANSFER_STRIDE分为多个区间

3.对每个区间的节点数据进行转移，转以后在table中将节点（即使该节点为null）置为ForwardingNode，标记为已转移。

4.最后table = nextTable。

需要注意的细节：

问：为什么要分为多个区间？

答：可以允许多个线程同时进行扩容不同的区间而不受其他线程影响。关键代码位置：第27行到第37行。

第63行条件判断开始处理链表节点的转移：

runBit记录节点的hash属性与原数组长度n的“&”运算结果，lastRun记录的是链表中最后面位置中节点的runBit值相同的子链表的头结点。

因为n是原数组的长度，而数组长度必须是2的整数次幂（n == 2的x次方）,所以n的二进制表示中，只有第x+1位是1，其他全为0。所以如果hash&n == 0，则表示hash中第x+1位为0，否则为1.

我们现在假设要转移的节点（node）所在数组中的位置为i，则i == node.hash&(n-1),如果node.hash&n == 0的话，那么node.hash&(2n-1) == node.hash&(n-1) == i。即扩容后node的位置不变。

如果node.hash&n > 0的话，则node.hash&(2n-1) == i + n。即扩容后node的位置向后移动n位。

上面的第64行到第87行是将当前节点分为2个子链表，分别是ln为hash&n == 0的子链表 和hn为hash&n > 0的子链表。根据我们之前讨论的结果ln应该还在当前的位置i，而hn则应该向后移动n位，即在i+n位置。

然后将旧数组的当前节点i位置用一个标志节点来标记此位置已经转移了。

转移树形结构的节点与链表类似，因为TreeNode是Node的子类，其本身也是一个链表，可以通过next属性遍历整个树。

再看下sizeCtl这个实例变量：

private transient volatile int sizeCtl;

当它为负值时，表示正在初始化或者扩容（-1表示初始化）；

否则，当table为null时，它为默认初始值0，或者保存着table的初始化值；

当table初始化结束时，它保存着下次需要扩容的阈值。

六、计数方法

 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) {
                 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();
             }
         }
     

该方法涉及的两个实例变量baseCount和counterCells是用来保存当前table中有多少数据的。

第17行之前是计算数据个数的，之后是检查是否需要扩容或者如果正在扩容则参与到扩容中。然后重新检查看看是否需要继续扩容。

其中的第24行判断，是错误的，在好几个方法中用到此种判断的都是同样的错误，请注意（这是jdk的一个BUG，在现在的已发布的JDK8-JDK11版本中都未解决，估计以后在JDK12发布版本中会fix掉，现在的openJDK12中已经fix了,参考https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8214427），其中的sc==rs + 1 || sc == rs + MAX_RESIZES应该改为sc == (rs << RESIZE_STAMP_SHIFT)+ 1 || sc == (rs << RESIZE_STAMP_SHIFT) + MAX_RESIZES,

用来判断扩容是否结束和扩容线程是否达到最大值。可以看下第31行，表示初始化扩容，所以开始扩容时， sizeCtl == (rs << RESIZE_STAMP_SHIFT) + 2,因为每个扩容线程在进行帮助扩容时都会使用CAS将sizeCtl+1，然后进入transfer，接着在transfer方法中，每当一个扩容线程结束时都会将sizeCtl - 1，所以当所有扩容线程结束时sizeCtl ==  (rs << RESIZE_STAMP_SHIFT)+ 1,因为第一个进入扩容的线程没有将sizeCtl+1.

七、最后看下size计算table中数据的个数的方法

 public int size() {
         long n = sumCount();
         return ((n < 0L) ? 0 :
                 (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
                 (int)n);
     }

 final long sumCount() {
         CounterCell[] as = counterCells; CounterCell a;
         long sum = baseCount;
         if (as != null) {
             for (int i = 0; i < as.length; ++i) {
                 if ((a = as[i]) != null)
                     sum += a.value;
             }
         }
         return sum;
     }

因为size中调用sumCount方法来间接计算个数，所以直接看sumCount方法。

它是将baseCount和counterCells中每个节点的value属性值累加在一起得到最后的数量。