ConcurrentHashmap源码好好给你说明白

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

一、静态工具方法

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

此方法是对给定的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：

 1 private final Node<K,V>[] initTable() {
 2         Node<K,V>[] tab; int sc;
 3         while ((tab = table) == null || tab.length == 0) {
 4             if ((sc = sizeCtl) < 0)
 5                 Thread.yield(); // lost initialization race; just spin
 6             else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
 7                 try {
 8                     if ((tab = table) == null || tab.length == 0) {
 9                         int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
10                         @SuppressWarnings("unchecked")
11                         Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
12                         table = tab = nt;
13                         sc = n - (n >>> 2);
14                     }
15                 } finally {
16                     sizeCtl = sc;
17                 }
18                 break;
19             }
20         }
21         return tab;
22     }

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

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

三、新增数据（put方法）

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

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

四、树化

 1 private final void treeifyBin(Node<K,V>[] tab, int index) {
 2         Node<K,V> b; int n, sc;
 3         if (tab != null) {
 4             if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
 5                 tryPresize(n << 1);
 6             else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
 7                 synchronized (b) {
 8                     if (tabAt(tab, index) == b) {
 9                         TreeNode<K,V> hd = null, tl = null;
10                         for (Node<K,V> e = b; e != null; e = e.next) {
11                             TreeNode<K,V> p =
12                                 new TreeNode<K,V>(e.hash, e.key, e.val,
13                                                   null, null);
14                             if ((p.prev = tl) == null)
15                                 hd = p;
16                             else
17                                 tl.next = p;
18                             tl = p;
19                         }
20                         setTabAt(tab, index, new TreeBin<K,V>(hd));
21                     }
22                 }
23             }
24         }
25     }

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

五、扩容方法（transfer）

  1 private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  2         int n = tab.length, stride;
  3         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
  4             stride = MIN_TRANSFER_STRIDE; // subdivide range
  5         if (nextTab == null) {            // initiating
  6             try {
  7                 @SuppressWarnings("unchecked")
  8                 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
  9                 nextTab = nt;
 10             } catch (Throwable ex) {      // try to cope with OOME
 11                 sizeCtl = Integer.MAX_VALUE;
 12                 return;
 13             }
 14             nextTable = nextTab;
 15             transferIndex = n;
 16         }
 17         int nextn = nextTab.length;
 18         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
 19         boolean advance = true;
 20         boolean finishing = false; // to ensure sweep before committing nextTab
 21         for (int i = 0, bound = 0;;) {
 22             Node<K,V> f; int fh;
 23             while (advance) {
 24                 int nextIndex, nextBound;
 25                 if (--i >= bound || finishing)
 26                     advance = false;
 27                 else if ((nextIndex = transferIndex) <= 0) {
 28                     i = -1;
 29                     advance = false;
 30                 }
 31                 else if (U.compareAndSwapInt
 32                          (this, TRANSFERINDEX, nextIndex,
 33                           nextBound = (nextIndex > stride ?
 34                                        nextIndex - stride : 0))) {
 35                     bound = nextBound;
 36                     i = nextIndex - 1;
 37                     advance = false;
 38                 }
 39             }
 40             if (i < 0 || i >= n || i + n >= nextn) {
 41                 int sc;
 42                 if (finishing) {
 43                     nextTable = null;
 44                     table = nextTab;
 45                     sizeCtl = (n << 1) - (n >>> 1);
 46                     return;
 47                 }
 48                 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
 49                     if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
 50                         return;
 51                     finishing = advance = true;
 52                     i = n; // recheck before commit
 53                 }
 54             }
 55             else if ((f = tabAt(tab, i)) == null)
 56                 advance = casTabAt(tab, i, null, fwd);
 57             else if ((fh = f.hash) == MOVED)
 58                 advance = true; // already processed
 59             else {
 60                 synchronized (f) {
 61                     if (tabAt(tab, i) == f) {
 62                         Node<K,V> ln, hn;
 63                         if (fh >= 0) {
 64                             int runBit = fh & n;
 65                             Node<K,V> lastRun = f;
 66                             for (Node<K,V> p = f.next; p != null; p = p.next) {
 67                                 int b = p.hash & n;
 68                                 if (b != runBit) {
 69                                     runBit = b;
 70                                     lastRun = p;
 71                                 }
 72                             }
 73                             if (runBit == 0) {
 74                                 ln = lastRun;
 75                                 hn = null;
 76                             }
 77                             else {
 78                                 hn = lastRun;
 79                                 ln = null;
 80                             }
 81                             for (Node<K,V> p = f; p != lastRun; p = p.next) {
 82                                 int ph = p.hash; K pk = p.key; V pv = p.val;
 83                                 if ((ph & n) == 0)
 84                                     ln = new Node<K,V>(ph, pk, pv, ln);
 85                                 else
 86                                     hn = new Node<K,V>(ph, pk, pv, hn);
 87                             }
 88                             setTabAt(nextTab, i, ln);
 89                             setTabAt(nextTab, i + n, hn);
 90                             setTabAt(tab, i, fwd);
 91                             advance = true;
 92                         }
 93                         else if (f instanceof TreeBin) {
 94                             TreeBin<K,V> t = (TreeBin<K,V>)f;
 95                             TreeNode<K,V> lo = null, loTail = null;
 96                             TreeNode<K,V> hi = null, hiTail = null;
 97                             int lc = 0, hc = 0;
 98                             for (Node<K,V> e = t.first; e != null; e = e.next) {
 99                                 int h = e.hash;
100                                 TreeNode<K,V> p = new TreeNode<K,V>
101                                     (h, e.key, e.val, null, null);
102                                 if ((h & n) == 0) {
103                                     if ((p.prev = loTail) == null)
104                                         lo = p;
105                                     else
106                                         loTail.next = p;
107                                     loTail = p;
108                                     ++lc;
109                                 }
110                                 else {
111                                     if ((p.prev = hiTail) == null)
112                                         hi = p;
113                                     else
114                                         hiTail.next = p;
115                                     hiTail = p;
116                                     ++hc;
117                                 }
118                             }
119                             ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
120                                 (hc != 0) ? new TreeBin<K,V>(lo) : t;
121                             hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
122                                 (lc != 0) ? new TreeBin<K,V>(hi) : t;
123                             setTabAt(nextTab, i, ln);
124                             setTabAt(nextTab, i + n, hn);
125                             setTabAt(tab, i, fwd);
126                             advance = true;
127                         }
128                     }
129                 }
130             }
131         }
132     }

总体逻辑：

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这个实例变量：

 1 private transient volatile int sizeCtl; 

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

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

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

 六、计数方法

 1 private final void addCount(long x, int check) {
 2         CounterCell[] as; long b, s;
 3         if ((as = counterCells) != null ||
 4             !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
 5             CounterCell a; long v; int m;
 6             boolean uncontended = true;
 7             if (as == null || (m = as.length - 1) < 0 ||
 8                 (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
 9                 !(uncontended =
10                   U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
11                 fullAddCount(x, uncontended);
12                 return;
13             }
14             if (check <= 1)
15                 return;
16             s = sumCount();
17         }
18         if (check >= 0) {
19             Node<K,V>[] tab, nt; int n, sc;
20             while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
21                    (n = tab.length) < MAXIMUM_CAPACITY) {
22                 int rs = resizeStamp(n);
23                 if (sc < 0) {
24                     if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
25                         sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
26                         transferIndex <= 0)
27                         break;
28                     if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
29                         transfer(tab, nt);
30                 }
31                 else if (U.compareAndSwapInt(this, SIZECTL, sc,
32                                              (rs << RESIZE_STAMP_SHIFT) + 2))
33                     transfer(tab, null);
34                 s = sumCount();
35             }
36         }
37     

该方法涉及的两个实例变量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中数据的个数的方法

 1 public int size() {
 2         long n = sumCount();
 3         return ((n < 0L) ? 0 :
 4                 (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
 5                 (int)n);
 6     }
 7
 8
 9
10 final long sumCount() {
11         CounterCell[] as = counterCells; CounterCell a;
12         long sum = baseCount;
13         if (as != null) {
14             for (int i = 0; i < as.length; ++i) {
15                 if ((a = as[i]) != null)
16                     sum += a.value;
17             }
18         }
19         return sum;
20     }

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

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