上一章：预热(内部一些小方法分析)
put()方法是并发HashMap源码分析的重点方法，这里涉及到并发扩容，桶位寻址等等… JDK1.8 ConcurrentHashMap结构图：1、put方法源码解析
// 向并发Map中put一个数据public V put(K key, V value) { return putVal(key, value, false);}// 向并发Map中put一个数据// Key: 数据的键// value：数据的值// onlyIfAbsent：是否替换数据：// 如果为false，则当put数据时，遇到Map中有相同K,V的数据，则将其替换// 如果为true，则当put数据时，遇到Map中有相同K,V的数据，则不做替换，不插入final V putVal(K key, V value, boolean onlyIfAbsent) { // 控制k 和 v 不能为null if (key == null || value == null) throw new NullPointerException(); // 通过spread方法，可以让高位也能参与进寻址运算，使最终得到的hash值更分散 int hash = spread(key.hashCode()); // binCount表示当前k-v 封装成node插入到指定桶位后，在桶位中的所属链表的下标位置 // =0 表示当前桶位为null，node可以直接放入 // >0 表示当前桶位中有节点，遍历链表，将封装k-v的新node放入链表末尾，并记录链表末尾的下标binCount // =2 表示当前桶位**可能**已经树化为红黑树了 int binCount = 0; // tab 引用map对象的table// 自旋 for (Node<K,V>[] tab = table;;) { // f 表示桶位的头结点 // n 表示散列表数组的长度 // i 表示key通过寻址计算后，得到的桶位下标 // fh 表示桶位头结点的hash值 Node<K,V> f; int n, i, fh; // ----------------------------------------------------------------------------- // CASE1：成立，表示当前map中的table尚未初始化... if (tab == null || (n = tab.length) == 0) // 对map中的table进行初始化 tab = initTable(); // ----------------------------------------------------------------------------- // CASE2：table已经初始化，此时根据寻址算法确定一个桶，并且桶的头结点f为null // i 表示key使用路由寻址算法得到key对应table数组的下标位置，tabAt方法获取指定桶位i的头结点f else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 这时候就可以将封装k-v的结点直接放入桶 // casTabAt通过CAS的方式去向Node数组指定位置i设置节点值，设置成功返回true 否则返回false if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break; } // ----------------------------------------------------------------------------- // CASE3：table已经初始化，寻址得到的桶位中的头结点f不是null，如果该头结点f的hash值fh=-1： // 则，表示当前节点是FWD(forwarding)节点 // 如果CASE3条件成立：表示当前桶位的头结点为 FWD结点，表示目前map正处于扩容过程中.. else if ((fh = f.hash) == MOVED) // 发现f是FWD结点后，当前结点有义务去帮助当前map对象完成数据迁移工作... // 等学完扩容再来分析这里~ tab = helpTransfer(tab, f); // ----------------------------------------------------------------------------- // CASE4：CASE1-3都不满足时，那么当前桶位存放的可能是链表也可能是红黑树代理结点TreeBin else { // 保留替换之前的数据引用：当新插入的key存在后，会将旧值赋给OldVal，返回给put方法调用 V oldVal = null; // 使用synchronized加锁“头节点”（**理论上是“头结点”**) synchronized (f) { // ----------------------------------------------------------------------- // CASE5：tabAt(tab, i) == f // 对比一下当前桶位的头节点是否为之前获取的头结点：为什么又要对比一下？ // 如果其它线程在当前线程之前将该桶位的头结点修改掉了，当前线程再使用sync对该节点f加锁就有问题了（锁本身加错了地方~） if (tabAt(tab, i) == f) {// 如果条件成立，说明加锁的对象f没有问题，持有锁！ // ------------------------------------------------------------------ // CASE6：fh >= 0) // 如果条件成立，说明当前桶位就是普通链表桶位,这里回顾下常量属性字段： // static final int MOVED = -1; 表示当前节点是FWD(forwarding)节点 // static final int TREEBIN = -2; 表示当前节点已经树化 if (fh >= 0) { // 1.当前插入key与链表当中所有元素的key都不一致时，当前的插入操作是追加到链表的末尾，binCount此时表示链表长度 // 2.当前插入key与链表当中的某个元素的key一致时，当前插入操作可能就是替换了。binCount表示冲突位置（binCount - 1） binCount = 1; // 迭代循环当前桶位的链表，e是每次循环处理节点。 for (Node<K,V> e = f;; ++binCount) { // 当前循环遍历节点的key K ek; // -------------------------------------------------------- // CASE7： // 条件一：e.hash == hash // 成立：表示循环的当前元素的hash值与插入节点的hash值一致,需要进一步判断 // 条件二：((ek = e.key) == key ||(ek != null && key.equals(ek))) // 成立：说明循环的当前节点与插入节点的key一致，确实发生冲突了~ if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { // 将当前循环的元素的值赋值给oldVal oldVal = e.val; // 传入的putVal方法参数onlyIfAbsent：是否替换数据： // false，当put数据时，遇到Map中有相同K,V的数据，则将其替换 // true，当put数据时，遇到Map中有相同K,V的数据，则不做替换，不插入 if (!onlyIfAbsent) e.val = value; break; } // -------------------------------------------------------- // CASE8： // 当前元素与插入元素的key不一致时，会走下面程序: // 1.更新循环遍历的节点为当前节点的下一个节点 // 2.判断下一个节点是否为null，如果是null，说明当前节点已经是队尾了，插入数据需要追加到队尾节点的后面。 Node<K,V> pred = e; if ((e = e.next) == null) { pred.next = new Node<K,V>(hash, key, value, null); break; } } } // ------------------------------------------------------------------ // CASE9：f instanceof TreeBin // 如果条件成立，表示当前桶位是红黑树代理结点TreeBin //（前置条件：该桶位一定不是链表） else if (f instanceof TreeBin) { // p表示红黑树中如果与你插入节点的key 有冲突节点的话，则putTreeVal方法会返回冲突节点的引用。 Node<K,V> p; // 强制设置binCount为2，因为binCount <= 1 时有其它含义，所以这里设置为了2 （回头讲addCount的时候会详细介绍） binCount = 2; // 条件一成立，说明当前插入节点的key与红黑树中的某个节点的key一致，冲突了： // putTreeVal向红黑树中插入结点，插入成功返回null，否则返回冲突结点对象 if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) { // 将冲突节点的值赋值给oldVal oldVal = p.val; if (!onlyIfAbsent) p.val = value; } } } } // ------------------------------------------------------------------ // CASE10：binCount != 0 // 说明当前桶位不为null，可能是红黑树也可能是链表 if (binCount != 0) { // 如果binCount>=8 表示处理的桶位一定是链表 if (binCount >= TREEIFY_THRESHOLD) // 因为桶中链表长度大于了8，需要树化： // 调用转化链表为红黑树的方法 treeifyBin(tab, i); // 说明当前线程插入的数据key，与原有k-v发生冲突，需要将原数据v返回给调用者。 if (oldVal != null) return oldVal; break; } } } // Map中的元素数据量累加方法：有额外的以下功能 // 1.统计当前table一共有多少数据 // 2.并判断是否达到扩容阈值标准，触发扩容。 addCount(1L, binCount); return null;}
2、initTable方法源码分析
第一次放元素时，初始化桶数组：
/** * table初始化 */private final Node<K,V>[] initTable() { // tab: 引用map.table// sc: sizeCtl的临时值 // sizeCtl：默认为0，用来控制table的状态、以及初始化和扩容操作: // sizeCtl<0表示table的状态: //（1）=-1，表示有其他线程正在进行初始化操作。（其他线程就不能再进行初始化，相当于一把锁）//（2）=-(1 + nThreads)，表示有n个线程正在一起扩容。 // sizeCtl>=0表示table的初始化和扩容相关操作：//（3）=0，默认值，后续在真正初始化table的时候使用，设置为默认容量DEFAULT_CAPACITY --> 16。//（4）>0，将sizeCtl设置为table初始容量或扩容完成后的下一次扩容的门槛。 Node<K,V>[] tab; int sc; // 附加条件的自旋： 条件是map.table尚未初始化... while ((tab = table) == null || tab.length == 0) { // ----------------------------------------------------------------------------- // CASE1: sizeCtl) < 0 // sizeCtl < 0可能是以下2种情况： //（1）-1，表示有其他线程正在进行table初始化操作。//（2）-(1 + nThreads)，表示有n个线程正在一起扩容。 if ((sc = sizeCtl) < 0) // 这里sizeCtl大概率就是-1，表示其它线程正在进行创建table的过程，当前线程没有竞争到初始化table的锁，进而当前线程被迫等待... Thread.yield(); // ----------------------------------------------------------------------------- // CASE2：sizeCtl) >= 0 且U.compareAndSwapInt(this, SIZECTL, sc, -1)结果为true // U.compareAndSwapInt(this, SIZECTL, sc, -1)：以CAS的方式修改当前线程的sizeCtl为-1， // sizeCtl如果成功被修改为-1，就返回true，否则返回false。 // 当返回true时，则该线程就可以进入下面的else if代码块中，这时候sizeCtl=-1相当于是一把锁，表示下面的else if代码块已经被该线程占用，其他线程不能再进入~ else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { // ---------------------------------------------------------------------- // CASE3: 这里为什么又要判断呢？ // 为了防止其它线程已经初始化table完毕了，然后当前线程再次对其初始化..导致丢失数据。// 如果条件成立，说明其它线程都没有进入过这个if块，当前线程就是具备初始化table权利了。 if ((tab = table) == null || tab.length == 0) { // sc大于等于0的情况如下： //（3）=0，默认值，后续在真正初始化table的时候使用，设置为默认容量DEFAULT_CAPACITY --> 16。//（4）>0，将sizeCtl设置为table初始容量或扩容完成后的下一次扩容的门槛。 // 如果sc大于0,则创建table时使用sc为指定table初始容量大小， // 否则使用16默认值DEFAULT_CAPACITY int n = (sc > 0) ? sc : DEFAULT_CAPACITY; @SuppressWarnings("unchecked") // 创建新数组nt Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; // 将新数组nt赋值给table、tab table = tab = nt; // sc设置为下次散列表扩容的门槛：0.75n sc = n - (n >>> 2); } } finally { // 将sc赋值给sizeCtl，分为一下2种情况： // 1、当前线程既通过了CASE2的判断，也通过了CASE3的判断： // 则，当前线程是第一次创建map.table的线程，那么，sc就表示下一次扩容的阈值。 // 2、当线程通过了CASE2的判断，但是没有通过CASE3的判断： // 则，当前线程并不是第一次创建map.table的线程，当前线程通过CASE2的判断时，将 // sizeCtl设置为了-1 ，那么在该线程结束上面的代码逻辑之后，需要将sc修改回进入CASE2之前的sc值。 sizeCtl = sc; } break; } } return tab;}
（1）使用CAS锁控制只有一个线程初始化桶数组；
（2）sizeCtl在初始化后存储的是扩容门槛；
（3）扩容门槛写死的是桶数组大小的0.75倍，桶数组大小即map的容量，也就是最多存储多少个元素。
3、addCount方法(难点)
在阅读addCount方法源码之前，最好再去熟悉下LongAdder源码：一篇带你解析入门LongAdder源码
addCount方法作用：每次添加元素后，元素数量加1，并判断是否达到扩容门槛，达到了则进行扩容或协助扩容。
/** * Map中的元素数据量累加方法：有额外的以下功能 * 1.统计当前table一共有多少数据 * 2.并判断是否达到扩容阈值标准，触发扩容 */private final void addCount(long x, int check) { // as 表示 LongAdder.cells // b 表示LongAdder.base // s 表示当前map.table中元素的数量 CounterCell[] as; long b, s; // -------------------------统计当前table一共有多少数据---------------------------------- // CASE1: // (as = counterCells) != null // 条件一：true->表示cells已经初始化了，当前线程应该去使用hash寻址找到合适的cell 去累加数据 // false->表示当前线程应该直接将数据累加到base（没有线程竞争） // !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x) // 条件二：false->表示写base成功，数据累加到base中了，当前竞争不激烈，不需要创建cells // true->表示写base失败，与其他线程在base上发生了竞争，当前线程应该去尝试创建cells。 if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { // 有几种情况进入到if块中？ // 条件一为true->表示cells已经初始化了，当前线程应该去使用hash寻址找到合适的cell去累加数据 // 条件二为true->表示写base失败，与其他线程在base上发生了竞争，当前线程应该去尝试创建cells。 // a 表示当前线程hash寻址命中的cell CounterCell a; // v 表示当前线程写cell时的期望值 long v; // m 表示当前cells数组的长度 int m; // true -> 未发生线程竞争 false->发生线程竞争 boolean uncontended = true; // --------------------------------------------------------------------------- // CASE2: // 条件一：as == null || (m = as.length - 1) < 0 // true-> 表示当前线程是通过写base竞争失败（CASE1的条件二），然后进入的if块，就需要调用fullAddCount方法去扩容或者重试.. // （fullAddCount方法就类似于LongAdder.longAccumulate方法） // 条件二：a = as[ThreadLocalRandom.getProbe() & m]) == null 前置条件：cells已经初始化了 // true->表示当前线程命中的cell表格是个空的，需要当前线程进入fullAddCount方法去初始化cell，放入当前位置. // 条件三：!(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x) // 前置条件：条件二中当前线程命中的cell表格不是空的~ // false->取反得到false，表示当前线程使用cas方式更新当前命中的cell成功 // true->取反得到true,表示当前线程使用cas方式更新当前命中的cell失败，需要进入fullAddCount进行重试或者扩容cells。 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); // 考虑到fullAddCount里面的事情比较累，就让当前线程不参与到扩容相关的逻辑了，直接返回到调用点。 return; } if (check <= 1) return; // sumCount统计当前散列表元素个数sum = base + cells[0] + ... + cells[n]，这是一个期望值 s = sumCount(); } // -------------------------判断是否达到扩容阈值标准，触发扩容---------------------------- // CASE3: // check >= 0表示一定是一个put操作调用的addCount，check < 0是remove操作调用的addCount方法 if (check >= 0) { // tab 表示 map.table // nt 表示 map.nextTable // n 表示map.table数组的长度 // sc 表示sizeCtl的临时值 Node<K,V>[] tab, nt; int n, sc; /** * sizeCtl < 0 * 1. -1 表示当前table正在初始化（有线程在创建table数组），当前线程需要自旋等待.. * 2.表示当前table数组正在进行扩容 ,高16位表示：扩容的标识戳 低16位表示：（1 + nThread） 当前参与并发扩容的线程数量 * * sizeCtl = 0，表示创建table数组时 使用DEFAULT_CAPACITY为大小 * * sizeCtl > 0 * * 1. 如果table未初始化，表示初始化大小 * 2. 如果table已经初始化，表示下次扩容时的 触发条件（阈值） */ // 有条件自旋~ // 条件一：s >= (long)(sc = sizeCtl) // true -> 1.当前sizeCtl为一个负数 表示正在扩容中.. // 2.当前sizeCtl是一个正数，表示扩容阈值，但是s已经达到扩容阈值（需要扩容） // false -> 表示当前table尚未达到扩容阈值条件（不需要扩容） // 条件二：(tab = table) != null 恒成立 true // 条件三：(n = tab.length) < MAXIMUM_CAPACITY // true -> 当前table长度小于最大值限制，则可以进行扩容。 while (s >= (long)(sc = sizeCtl) && (tab = table) != null && (n = tab.length) < MAXIMUM_CAPACITY) { // 获取扩容唯一标识戳 // eg: 16 -> 32 扩容标识戳为：1000 0000 0001 1011 // 什么意思呢？ // 即，所有将map容量由16扩容到32的线程，其拿到的扩容唯一标识戳都是1000 0000 0001 1011 int rs = resizeStamp(n); // -------------------------------------------------------------------------- // CASE4: // 条件成立：表示当前table正在扩容，则，当前线程理论上应该协助table完成扩容 if (sc < 0) { // -------------------------------------------------------------- // CASE2: 条件1~4只要有个为true就会跳出循环，不会继续扩容~ // 条件一：(sc >>> RESIZE_STAMP_SHIFT) != rs // true -> 说明当前线程获取到的扩容唯一标识戳 非 本批次扩容 // false -> 说明当前线程获取到的扩容唯一标识戳 是 本批次扩容 // 条件二：JDK1.8 中有bug,jira已经提出来了,其实想表达的是 sc == (rs << 16 ) + 1 // true -> 表示扩容完毕，当前线程不需要再参与进来了 // false -> 扩容还在进行中，当前线程可以参与 // 条件三：JDK1.8 中有bug,jira已经提出来了,其实想表达的是: // sc == (rs << 16) + MAX_RESIZERS // true-> 表示当前参与并发扩容的线程达到了最大值 65535 - 1 // false->表示当前线程可以参与进来 //条件四：(nt = nextTable) == null // true -> 表示本次扩容结束 // false -> 扩容正在进行中 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || (nt = nextTable) == null || transferIndex <= 0) // 条件1~4只要有个为true就会跳出循环，不会继续扩容~ break; // -------------------------------------------------------------- // CASE5: // 前置条件：当前table正在执行扩容中（即，CASE4没有被通过）当前线程有机会参与进扩容。 // 条件成立：说明当前线程成功参与到扩容任务中，并且将sc低16位值加1，表示多了一个线程参与工作~ // 条件失败： // 1.当前有很多线程都在此处尝试修改sizeCtl，有其它一个线程修改成功了 // 导致你的sc期望值与内存中的值不一致，CAS修改失败。(下次自选大概率不会在来到这里~) // 2.transfer任务内部的线程也修改了sizeCtl。 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) // 扩容（迁移数据）：协助扩容线程，持有nextTable参数，进入该方法协助扩容~ transfer(tab, nt); } // -------------------------------------------------------------------------- // CASE6: 以CAS的方式去更新sc，更新成功返回true，否则返回false // 条件成立，说明当前线程是触发扩容的**第一个**线程，在transfer方法需要做一些扩容准备工作: // rs << RESIZE_STAMP_SHIFT：将扩容唯一标识戳左移16位 eg: // 1000 0000 0001 1011 << 16 得到 1000 0000 0001 1011 0000 0000 0000 0000 // 紧接这 (rs << RESIZE_STAMP_SHIFT) + 2)操作： // 1000 0000 0001 1011 0000 0000 0000 0000 + 2 // => 1000 0000 0001 1011 0000 0000 0000 0010，这个二进制数有如下含义: // sizeCtl的高16位: 1000 0000 0001 1011 表示当前的扩容标识戳 // sizeCtl的低16位: 0000 0000 0000 0010 表示(1 + nThread)，即，目前有多少个线程正在参与扩容~ // 那么这里的n是怎么来的呢？ // eg: (rs << RESIZE_STAMP_SHIFT) + 2 这里的2，就是1 + 1，后面的1就是对1*Thread，即(1+1*Threads) else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) // 扩容（迁移数据）：触发扩容条件的线程 不持有nextTable transfer(tab, null); // 重新计算table中的元素个数 s = sumCount(); } }}
4、总结
（1）元素个数的存储方式类似于LongAdder类，存储在不同的段上，减少不同线程同时更新size时的冲突；
（2）计算元素个数时把这些段的值及baseCount相加算出总的元素个数；
（3）正常情况下sizeCtl存储着扩容门槛，扩容门槛为容量的0.75倍；
（4）扩容时sizeCtl高位存储扩容邮戳(resizeStamp)，低位存储扩容线程数加1（1+nThreads）；
（5）其它线程添加元素后如果发现存在扩容，也会加入的扩容行列中来；
以上就是ConcurrentHashMap源码的put存入数据的方法以及相关方法，由于transfer 迁移数据这个方法比较复杂，我们放在下一篇文章中单独分析~也希望大家多多关注的其他内容！
没有天生的信心，只有不断培养的信心。
