构造方法
无参的构造方法什么都没有，看一下有参构造方法，先对传进来的容量的进行判断是否合法，然后计算cap当传进来的值大于最大容量的二倍的时候直接赋值最大容量，否则调用tableSizeFor函数计算出大于当前initialCapacity + (initialCapacity >>> 1) + 1)的最近的2的幂次方数字，所以当initialCapacity 为32时候cap为64.将值赋值给sizeCtl;
sizeCtl的含义：
当sizeCtl的值为0时候，表示没有初始化，初始容量为默认值16；
当SizeCtl大于0的时候，如果没有初始化代表当时的容量，如果初始化过了，则代表当前数组扩容的阈值。
当SizeClt的值等于-1的时候，代表正在进行初始化。
当SizeCtl的值小于-1的时候。代表有-（1+n）个线程在进行扩容
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
putVal方法
首先进行判空，不容易key或者value为空否则抛出空指针异常，通过spread函数计算哈希值，进入for循环变量数组，如果table数组没有进行初始化，则进入函数initTable()函数进行初始化，然后再for循环里面就可以进行插入值，进入第一个else if逻辑判断当前使用上面算出来的hash值，计算出存储位置的下标i,判断该位置是否有元素，如果没有则直接视图CAS替换，如果有且该位置上数据的hash值等于MOVED说明由数组在扩容，所有当前线程需要协助扩容，进入helpTransfer逻辑进行协助扩容，如果都不满足，则将当前位置上的元素使用synchronized加锁，判断当前的节点的元素是不是数节点，将元素插入以当前位置元素为头节点的链表之中，或者插入到树中。完事之后进入方法addCount将总结点的数量加一。这个方法逻辑类似于JDK8中的LongAdder
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;
}
initTable()方法
该方法主要是对数组进行初始化，进入循环对数组进行初始化，退出的条件就是数组初始化成功，首先检查是不是有其他线程对数组进行初始化如果有的话进行线程让步，否则进入下面循环使用CAS将SizeCtl标志位设置为-1，表示在初始化，再次进行判断，数组是否初始化，确保安全，如果没有则进入初始化逻辑，然后判断sc的值也就是Sizectl之前的值，是是不是大于0，使用这个容量创建Node数组，将成员变量赋值。 sc = n - (n >>> 2);这一句就是算出下一次扩容的阈值，也就是新容量的0.75倍，finally将新的阈值赋值给sizeCtl。跳出循环。
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();
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;
}
addCount方法
数组CounterCell所代表的意思就是当CAS对baseCount添加失败之后就使用TheadLocalRandom在数组中取任意下标，在此位置上进行CAS，直到成功。
具体逻辑：
进入if判断，进入方法内逻辑的条件是：CounterCell不为空，或者CAS对baseCount加1失败，
如果数组为null，或者数组的值小于0，或者通过当前线程TheadLocalRandom算出来的下标值位置上的元素为null，则说明没有对该位置初始化或者初始化了但是对该位置元素CAS加1失败了，则进入fullAddCount逻辑,fullAddCount的逻辑主要是对CounterCell的初始化。或者对其的扩容，使用CAS加TheadLocalRandom对下标位置数进行加1操作。下面的if逻辑是判断数组是否需要扩容的逻辑,nextTable是扩容之后的数组，调用transfer逻辑进行扩容，如果sc小于0代表正在扩容，则进行协助扩容，否则使用CAS替换标志位进行扩容。
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();
}
}
}
