接下来就讲解put里面的三个方法，分别是
1、数组初始化方法initTable()
2、线程协助扩容方法helpTransfer()
3、计数方法addCount()
首先是数组初始化，再将源码之前，先得搞懂里面的一个重要参数，那就是sizeCtl。
sizeCtl默认为0，代表数组未初始化。
sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值。
sizeCtl为-1，表示数组正在进行初始化。
sizeCtl小于0，并且不是-1，表示数组正在扩容，-（1+n），表示此时有n个线程共同完成数组的扩容操作。
接下来讲解initTable()方法
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
//第一次put的时候，table还没被初始化，所以能进入while。sizeCtl默认值是0，当有两个线程都想进行初始化时，线程A CAS成功，也就是else if为true，继续执行下面，而另一个线程cas就是false，就重新进行while循环，而这时sizeCtl为-1.所以这个线程就
放弃cpu的控制权，说白了就是在多线程下保证初始化只执行一次。
while ((tab = table) == null || tab.length == 0) {//tab在这里赋值，是table的引用
if ((sc = sizeCtl) < 0)//sc在这里赋值。是sizeCtl的引用。
Thread.yield(); // lost initialization race; just spin//线程放弃cpu的控制权。
//SIZECTL：表示当前对象的内存偏移量，sc表示期望值，-1表示要替换的值，设定为-1表示要初始化表了
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//SIZECTL是地址偏移量，如果SIZECTL对应地址的值与sc相等，说明当前的线程是第一个到达这条语句的线程，那么就会将SIZECTL地址所对应的值替换成-1，而SIZECTL地址偏移量对应的对象就是sizeCtl
try {
if ((tab = table) == null || tab.length == 0) {//再次进行判断，防止在进行U.compareAndSwapInt(this, SIZECTL, sc, -1)的时候有其他线程并发进入方法，导致出错，使用双重锁
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;//sc在前边就赋值了，如果有初值，那么这里n就是设定的初始值，否则n就是默认容量。16
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];//基于初始长度，构建数组对象
table = tab = nt;
sc = n - (n >>> 2);//这里就是计算扩容阈值，并赋值给sc。也就是n-0.25n = 0.75n
}
} finally {
sizeCtl = sc;//将扩容阈值，赋值给sizeCtl，第一次初始化后。
}
break;
}
}
return tab;
}
所以在这个方法中，sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值。就是这个含义。
第二个要讲解的方法是addCount方法。
这段代码分为两个部分，一个是计数部分，另一个是扩容部分。
<用两种方法进行计数，一个是用cas对baseCount<baseCount是一个全局属性，volatile的>进行加法计数，另一个是用CounterCell数组，其实CounterCell对象就有一个属性是value，用CounterCell构建一个数组，然后哪个线程要进行加法，就用这个线程产生一个hash值，并用这个数与CounterCell数组的长度减一做与运算，得到的结果就是CounterCell数组的index，然后对这个index对应的CounterCell对象的value做加法。在最后统计计数的时候是用：baseCount+每个CounterCell的value>
countcell就是通过分散计算来减少竞争。其内部有一个基础值和一个哈希表。当没有竞争的时候在基础值上计数。有竞争的时候通过哈希表计数（每个线程有一个哈希值，通过哈希值确定在哈希表的位置，在这个位置进行计数，不同位置互不影响）
计数部分：通过baseCount和CounterCell数组，二选一的参与计数
扩容部分：当大于扩容阈值的时候进行扩容，当满足扩容条件时才能扩容
如果有别的线程正在进行扩容，那么就存在nextTable（一个全局属性，表示正在扩容的线程），就把nextTable作为参数传入transfer方法，就是让这个线程帮忙扩容nextTable
如果没有别的线程正在扩容，那么就把null传入transfer方法，让transfer方法创建一个nextTable
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;//as表示counterCells引用， b表示获取的baseCount值， s应该是表示元素个数。
//当CounterCell数组不为空，则优先利用数组中的CounterCell记录数量
//或者当baseCount的累加操作失败，会利用数组中的CounterCell记录数量
//条件一：as!=null true:表示counterCells以及初始化过了，当前线程应该将数据写入到对应的counterCell中。
//as==null 也就是条件1为false，那么表示counterCells未初始化，当前所有线程应该将数据写到baseCount中。
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {//条件二：true：表示当前线程cas替换数据成功 false表示发生竞争了，可能需要重试或者扩容。//因为这里有个！，所以应该false才能进入
//什么时候会进入到if判断里面
//1.条件一：as!=null true:表示counterCells以及初始化过了，当前线程应该将数据写入到对应的counterCell中。
//2.条件二：false表示发生竞争了，可能需要重试或者扩容
CounterCell a; long v; int m;//a表示当前线程命中的CounterCell单元格 v表示期望值，m表示as数组的长度。
boolean uncontended = true; //标识是否有多线程竞争 ，//true表示未发生竞争，false表示发生竞争。
//当as数组为空
//或者当as长度为0
//或者当前线程对应的as数组桶位的元素为空
//或者当前线程对应的as数组桶位不为空，但是累加失败
//条件一：as==null 为true，说明counterCells未初始化，那么上面就是根据多线程写base发生竞争进入到这里的。
//as!=null为false，说明counterCells已经初始化了。当前线程应该是找自己的counterCells写值。
if (as == null || (m = as.length - 1) < 0 ||
//ThreadLocalRandom.getProbe()表示当前线程的hash值。 m是CountCell长度-1，as.length一定是2的次方数，比如长度为16，那么减一就是15
//也就是b1111，那么与上之后肯定是小于等于当前长度的值，也就是下标。
//如果a==null，也就是条件为true，说明当前线程对应下标的CountCell为空，那么就需要创建
//如果是false，不为空，说明下一步想要将x的值添加到CountCell中。
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
//条件三：true：表示cas失败，意味着当前线程对应的CountCell有竞争，
//false，表示cas成功
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
//都有哪些情况会调用下面的方法：
//1.as==null 为true，说明counterCells未初始化，那么上面就是根据多线程写base发生竞争进入到这里的，那么初始化。
//2.如果a==null，也就是条件为true，说明当前线程对应下标的CountCell为空，那么就需要创建
//3.true：表示cas失败，意味着当前线程对应的CountCell有竞争，那么就可能是重试或者扩容。
//以上任何一种情况成立，都会进入该方法，传入的uncontended是false
fullAddCount(x, uncontended);//也就是countCells是一个全局得volatile的CountCell数组，创建实在fullAddCount方法中。
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) { //sc小于0，说明有线程正在扩容，那么会协助扩容
//扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
//扩容线程加1，成功后，进行协助扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);//协助扩容，newTable不为null
}
//否则sc>=0,说明是首个扩容的线程，所以transfer传入的参数是null
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
接下来就是讲解上面的fullAddCount方法
① 当CounterCell数组不为空，优先对CounterCell数组中的CounterCell的value累加
② 当CounterCell数组为空，会去创建CounterCell数组，默认长度为2，并对数组中的CounterCell的value累加
③ 当数组为空，并且此时有别的线程正在创建数组，那么尝试对baseCount做累加，成功即返回，否则自旋
private final void fullAddCount(long x, boolean wasUncontended) {//wasUncontended只有counterCells初始化之后，并且当前线程竞争修改失败，才会是false。其余情况都是true。
int h;//h表示线程的hash值。
//获取当前线程的hash值
if ((h = ThreadLocalRandom.getProbe()) == 0) {//条件成立：说明当前线程还未分配hash值。
ThreadLocalRandom.localInit();//给当前线程分配hash值 // force initialization
h = ThreadLocalRandom.getProbe();//取出当前线程的hash值，赋值给h
wasUncontended = true;//为啥这里强制设为true，当前线程肯定是写入到了countCells[0]位置,不把它当作一次真正的竞争。
}
boolean collide = false; //标识是否有冲突，如果最后一个桶不是null，那么为true //表示扩容意向 false一定不会扩容，true可能会扩容 // True if last slot nonempty
for (;;) {//自旋
CounterCell[] as; CounterCell a; int n; long v;//as表示counterCells引用，a表示当前线程命中的CounterCell，n表示counterCells数组长度，v表示期望值
//数组不为空，优先对数组中CouterCell的value累加
//CASE1:表示countCells已经初始化了，当前线程应该将数据写入到对应的CounterCell中。
if ((as = counterCells) != null && (n = as.length) > 0) {
//2.如果a==null，也就是条件为true，说明当前线程对应下标的CountCell为空，那么就需要创建
//3.true：表示cas失败，意味着当前线程对应的CountCell有竞争，那么就可能是重试或者扩容。这两种情况会进入到这个if判断中
//线程对应的桶位为null
//CASE1.1:a = as[(n - 1) & h]) == null true表示当前线程对应的下标位置的CounterCell为null，需要创建new CounterCell
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { //true：表示当前锁未被占用，false表示锁被占用 // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create//创建CounterCell对象
//利用CAS修改cellBusy状态为1，成功则将刚才创建的CounterCell对象放入数组中
//条件一：true：表示当前锁未被占用，false表示锁被占用
//条件二：true：表示当前线程获取锁成功，false表示当前线程获取锁失败。
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;//是否创建成功的标记
try { // Recheck under lock
CounterCell[] rs; int m, j;//rs表示当前countCells引用，m表示rs的长度，j表示当前线程命中的下标。
//桶位为空， 将CounterCell对象放入数组
//条件一条件二恒成立
// rs[j = (m - 1) & h] == null为了防止其它线程初始化过该位置，然后当前线程再次初始化该位置，导致数据丢失。
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;//表示放入成功
}
} finally {
cellsBusy = 0;
}
if (created)//成功退出循环
break;
continue; //桶位已经被别的线程放置了已给CounterCell对象，继续循环 // Slot is now non-empty
}
}
collide = false;//将扩容意向改为false，原因是因为再CASE1.1中当前CounterCell都是为null，不可能不让写。因此不需要扩容。
}
//桶位不为空，重新计算线程hash值，然后继续循环
//CASE1.2：只有一种情况会来到这里，wasUncontended只有counterCells初始化之后，并且当前线程竞争修改失败，才会是false
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
//重新计算了hash值后，对应的桶位依然不为空，对value累加
//成功则结束循环
//失败则继续下面判断
//CASE1.3：当前线程rehash过hash值，然后新命中的CounterCell不为空。则来到这里。
//true：写成功，退出循环，
//false：表示rehash之后命中的新的cell也有竞争，重试1次 再重试一次
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
//数组被别的线程改变了，或者数组长度超过了可用cpu大小，重新计算线程hash值，否则继续下一个判断
//CASE1.4:条件一：n >= NCPU true->表示扩容意向改为false，表示不扩容了。false说明counterCells数组还可以扩容
//条件二：counterCells != as true表示其它线程已经扩容过了，当前线程rehash之后重试即可。
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
//当没有冲突，修改为有冲突，并重新计算线程hash，继续循环
//CASE1.5 !collide=true，设置扩容意向为true，但是不一定真的发生扩容。因为一旦进入这里，那么又会rehash一下，又会重来。
else if (!collide)
collide = true;
//如果CounterCell的数组长度没有超过cpu核数，对数组进行两倍扩容
//并继续循环
//CASE1.6:真正扩容的逻辑
//条件一：cellsBusy == 0 true表示当前无锁状态，当前线程可以去竞争这把锁。
//条件二：U.compareAndSwapInt(this, CELLSBUSY, 0, 1) true表示当前线程获取锁成功，可以执行扩容逻辑。
//false表示当前时刻有其它线程正在做扩容相关的操作。
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale //这里又有双重检测，就是为了防止扩容过了又再次扩容。
CounterCell[] rs = new CounterCell[n << 1];//扩容为两倍扩容
for (int i = 0; i < n; ++i)
rs[i] = as[i];//将旧数组的值放到新数组。
counterCells = rs;
}
} finally {
cellsBusy = 0; //释放锁
}
collide = false;
continue; // Retry with expanded table
}
h = ThreadLocalRandom.advanceProbe(h);//重置当前hash值 rehash
}
//CounterCells数组为空，并且没有线程在创建数组，修改标记，并创建数组，因为前面CASE1是数组不为空，所以这里是数组为空
//CASE2：当前条件countCells还未初始化，as为null
//条件一：cellsBusy == 0 true表示当前未加锁
//条件二：counterCells == as，为什么又重新比较一遍，明明前面CASE1已经赋值未null了。因为其它线程可能会在你给as赋值之后修改了counterCells。
//条件三：如果未true，表示获取锁成功，会把cellsBusy改成1。false表示其它线程正在持有这把锁，那么当前线程就进不了这里面了。
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {//为什么这里又判断了一下counterCells == as，防止其它线程已经初始化了，当前线程再次初始化，就会覆盖掉其它线程初始化的CountCell，导致丢失数据。
CounterCell[] rs = new CounterCell[2];//初始容量为2
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
//CASE3:
//1.当前cellsBusy加锁状态，表示其他线程正在初始化countCells，所以当前线程将值累加到baseCount。
//2.countCells被其它线程初始化后，当前线程需要将数据累加到base。
//数组为空，并且有别的线程在创建数组，那么尝试对baseCount做累加，成功就退出循环，失败就继续循环
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
总结：addCount方法通过属性baseCount 和 counterCell数组中所有的元素的和来记录size
在无竞争的情况下，通过cas当前map对象的baseCount为baseCount + 1，
有竞争情况下,上诉cas失败，会初始化一个长度为2的CounterCell数组，数组会扩容，每次扩容成两倍，每个线程有在counterCell数组中对应的位置(多个线程可能会对应同一个位置)， 如果位置上的CounterCell元素为空，就生成一个value为1的元素，如果不为空，则cas当前CounterCell元素的value为value + 1;如果都失败尝试cas当前map对象的baseCount为baseCount + 1。