ConcurrentHashMap1-8源码解读及如何保证线程安全，阿里三面

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）

正文

new Node<K,V>(hash, key, value, null))) // 比较并且交换值，如tab的第i项为空则用新生成的node替换
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED) // 该结点的hash值为MOVED
// 进行结点的转移（在扩容的过程中）
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) { // 加锁同步
if (tabAt(tab, i) == f) { // 找到table表下标为i的节点
if (fh >= 0) { // 该table表中该结点的hash值大于0
// binCount赋值为1
binCount = 1;
for (Node<K,V> e = f;; ++binCount) { // 无限循环
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) { // 结点的hash值相等并且key也相等
// 保存该结点的val值
oldVal = e.val;
if (!onlyIfAbsent) // 进行判断
// 将指定的value保存至结点，即进行了结点值的更新
e.val = value;
break;
}
// 保存当前结点
Node<K,V> pred = e;
if ((e = e.next) == null) { // 当前结点的下一个结点为空，即为最后一个结点
// 新生一个结点并且赋值给next域
pred.next = new Node<K,V>(hash, key,
value, null);
// 退出循环
break;
}
}
}
else if (f instanceof TreeBin) { // 结点为红黑树结点类型
Node<K,V> p;
// binCount赋值为2
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) { // 将hash、key、value放入红黑树
// 保存结点的val
oldVal = p.val;
if (!onlyIfAbsent) // 判断
// 赋值结点value值
p.val = value;
}
}
}
}
if (binCount != 0) { // binCount不为0
if (binCount >= TREEIFY_THRESHOLD) // 如果binCount大于等于转化为红黑树的阈值
// 进行转化
treeifyBin(tab, i);
if (oldVal != null) // 旧值不为空
// 返回旧值
return oldVal;
break;
}
}
}
// 增加binCount的数量
addCount(1L, binCount);
return null;
}

1.8的put中涉及table的初始化，树的转化，扩容等方法 initTable、tabAt、casTabAt、helpTransfer、putTreeVal、treeifyBin、addCount函数。后面会一一介绍

1.8putVal方法流程总结

1.当添加一对键值对的时候，首先会去判断保存这些键值对的数组是不是初始化了，如果没有的话就初始化数组

2.通过计算hash值来确定放在数组的哪个位置

3.如果这个位置为空则直接添加，如果不为空的话，则取出这个节点来

4.如果取出来的节点的hash值是MOVED(-1)的话，则表示当前正在对这个数组进行扩容，复制到新的数组，则当前线程也去帮助复制

5.最后一种情况就是，如果这个节点，不为空，也不在扩容，则通过synchronized来加锁，进行添加操作

6.然后判断当前取出的节点位置存放的是链表还是树

7.如果是链表的话，则遍历整个链表，直到取出来的节点的key来个要放的key进行比较，如果key相等，并且key的hash值也相等的话，

则说明是同一个key，则覆盖掉value，否则的话则添加到链表的末尾

8.如果是树的话，则调用putTreeVal方法把这个元素添加到树中去

最后在添加完成之后，会判断在该节点处共有多少个节点（注意是添加前的个数），如果达到8个以上了的话，

9.则调用treeifyBin方法来尝试将处的链表转为树，或者扩容数组

JDK1.8initTable()

在使用的时候才会初始化数组

并发问题是通过CAS操控sizeCtl变量实现的。

initTable源码

private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) { //第一次put的时候，table还没被初始化，进入while
if ((sc = sizeCtl) < 0) //sizeCtl初始值为0，当小于0的时候表示在别的线程在初始化表或扩展表
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { //SIZECTL：表示当前对象的内存偏移量，sc表示期望值，-1表示要替换的值，设定为-1表示要初始化表了
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY; //指定了大小的时候就创建指定大小的Node数组，否则创建指定大小(16)的Node数组
@SuppressWarnings(“unchecked”)
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc; //初始化后，sizeCtl长度为数组长度的3/4
}
break;
}
}
return tab;
}

initTable流程

1.如果sizeCtl小于0，说明别的数组正在进行初始化，则让出执行权

2.如果sizeCtl大于0的话，则初始化一个大小为sizeCtl的数组

3.否则的话初始化一个默认大小(16)的数组

4.然后设置sizeCtl的值为数组长度的3/4

tabAt函数

@SuppressWarnings(“unchecked”)
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
//强制去读取主存中的数据而不是线程自己的本地工作内存，保证数据是最新的
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);

}

此函数返回table数组中下标为i的结点，可以看到是通过Unsafe对象通过反射获取的，getObjectVolatile的第二项参数为下标为i的偏移地址。

casTabAt函数

static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
//使用cas的比较交换
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

此函数用于比较table数组下标为i的结点是否为c，若为c，则用v交换操作。否则，不进行交换操作。

helpTransfer函数

/**

• Helps transfer if a resize is in progress.
• 如果正在调整大小则帮忙转移
  */
  //将旧的数组中的元素复制到新的数组中
  final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
  Node<K,V>[] nextTab; int sc;
  //旧数组不为空且nextTable也不空的情况下才能复制
  if (tab != null && (f instanceof ForwardingNode) &&
  (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
  int rs = resizeStamp(tab.length);
  while (nextTab == nextTable && table == tab &&
  (sc = sizeCtl) < 0) {
  if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
  sc == rs + MAX_RESIZERS || transferIndex <= 0)
  break;
  //cas操作保证线程安全
  if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
  transfer(tab, nextTab);//调用扩容方法
  break;
  }
  }
  return nextTab;
  }
  return table;
  }

用于在扩容时将table表中的结点转移到nextTable中。

putTreeVal函数

final TreeNode<K,V> putTreeVal(int h, K k, V v) {
Class<?> kc = null;// 定义k的Class对象
// 标识是否已经遍历过一次树，未必是从根节点遍历的，但是遍历路径上一定已经包含了后续需要比对的所有节点
boolean searched = false;
// 从根节点开始遍历，没有终止条件，只能从内部退出
for (TreeNode<K,V> p = root;😉 {
int dir, ph; K pk;
//如果根节点为空，那么赋值当前节点就是根节点，结束循环
if (p == null) {
first = root = new TreeNode<K,V>(h, k, v, null, null);
break;
}
// 如果当前节点hash 大于 指定key的hash值
else if ((ph = p.hash) > h)
dir = -1;//要添加的元素应该放置在当前节点的左侧
else if (ph < h)//小于
dir = 1;//在右侧
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))// 如果当前节点的键对象 和 指定key对象相同
return p; // 那么就返回当前节点对象，在外层方法会对v进行写入

// 走到这一步说明 当前节点的hash值 和 指定key的hash值 是相等的，但是equals不等
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {

// 走到这里说明：指定key没有实现comparable接口 或者 实现了comparable接口并且和当前节点的键对象比较之后相等（仅限第一次循环）

if (!searched) {// 如果还没有比对过当前节点的所有子节点
TreeNode<K,V> q, ch;// 定义要返回的节点、和子节点
searched = true;//标识为已经遍历过
/*

• 红黑树也是二叉树，所以只要沿着左右两侧遍历寻找就可以了
• 这是个短路运算，如果先从左侧就已经找到了，右侧就不需要遍历了
• find 方法内部还会有递归调用
  */
  if (((ch = p.left) != null &&
  (q = ch.findTreeNode(h, k, kc)) != null) ||
  ((ch = p.right) != null &&
  (q = ch.findTreeNode(h, k, kc)) != null))
  return q;
  }
  // 走到这里就说明，遍历了所有子节点也没有找到和当前键equals相等的节点
  dir = tieBreakOrder(k, pk);// 再比较一下当前节点键和指定key键的大小
  }

TreeNode<K,V> xp = p; // 定义xp指向当前节点
/*

• 如果dir小于等于0，那么看当前节点的左节点是否为空，如果为空，就可以把要添加的元素作为当前节点的左节点，如果不为空，还需要下一轮继续比较
• 如果dir大于等于0，那么看当前节点的右节点是否为空，如果为空，就可以把要添加的元素作为当前节点的右节点，如果不为空，还需要下一轮继续比较
• 如果以上两条当中有一个子节点不为空，这个if中还做了一件事，那就是把p已经指向了对应的不为空的子节点，开始下一轮的比较
  */
  if ((p = (dir <= 0) ? p.left : p.right) == null) {
  // 如果恰好要添加的方向上的子节点为空，此时节点p已经指向了这个空的子节点
  TreeNode<K,V> x, f = first; // 获取当前节点的next节点
  first = x = new TreeNode<K,V>(h, k, v, f, xp);// 创建一个新的树节点
  if (f != null)
  f.prev = x;
  if (dir <= 0)
  xp.left = x; // 左孩子指向到这个新的树节点
  else
  xp.right = x;// 右孩子指向到这个新的树节点
  if (!xp.red)
  x.red = true;
  else {
  lockRoot();//加锁
  try {
  root = balanceInsertion(root, x);// 重新平衡，以及新的根节点置顶
  } finally {
  unlockRoot();//解锁
  }
  }
  break;
  }
  }
  assert checkInvariants(root);
  return null;
  }

此函数用于将指定的hash、key、value值添加到红黑树中，若已经添加了，则返回null，否则返回该结点。

treeifyBin函数

当数组长度小于64的时候，扩张数组长度一倍，否则的话把链表转为树

private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
System.out.println(“treeifyBin方\t==>数组长：”+tab.length);
if ((n = tab.length) < MIN_TREEIFY_CAPACITY) //MIN_TREEIFY_CAPACITY 64
tryPresize(n << 1); // 数组扩容
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) { //使用synchronized同步器，将该节点出的链表转为树
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null; //hd：树的头(head)
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) //把Node组成的链表，转化为TreeNode的链表，头结点任然放在相同的位置
hd = p; //设置head
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin<K,V>(hd));//把TreeNode的链表放入容器TreeBin中
}
}
}
}
}

此函数用于将桶中的数据结构转化为红黑树，其中，值得注意的是，当table的长度未达到阈值时，会进行一次扩容操作，该操作会使得触发treeifyBin操作的某个桶中的所有元素进行一

次重新分配，这样可以避免某个桶中的结点数量太大。

tryPresize方法

private final void tryPresize(int size) {
/*

• MAXIMUM_CAPACITY = 1 << 30
• 如果给定的大小大于等于数组容量的一半，则直接使用最大容量，
• 否则使用tableSizeFor算出来
• 后面table一直要扩容到这个值小于等于sizeCtrl(数组长度的3/4)才退出扩容
  /
  int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
  tableSizeFor(size + (size >>> 1) + 1);
  int sc;
  while ((sc = sizeCtl) >= 0) {
  Node<K,V>[] tab = table; int n;
  /
• 如果数组table还没有被初始化，则初始化一个大小为sizeCtrl和刚刚算出来的c中较大的一个大小的数组
• 初始化的时候，设置sizeCtrl为-1，初始化完成之后把sizeCtrl设置为数组长度的3/4
• 为什么要在扩张的地方来初始化数组呢？
• 这是因为如果第一次put的时候不是put单个元素，
• 而是调用putAll方法直接put一个map的话，在putALl方法中没有调用initTable方法去初始化table，
• 而是直接调用了tryPresize方法，所以这里需要做一个是不是需要初始化table的判断
  /
  if (tab == null || (n = tab.length) == 0) {
  n = (sc > c) ? sc : c;
  if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { //初始化tab的时候，把sizeCtl设为-1
  try {
  if (table == tab) {
  @SuppressWarnings(“unchecked”)
  Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
  table = nt;
  sc = n - (n >>> 2);
  }
  } finally {
  sizeCtl = sc;
  }
  }
  }
  /
• 一直扩容到的c小于等于sizeCtl或者数组长度大于最大长度的时候，则退出
• 所以在一次扩容之后，不是原来长度的两倍，而是2的n次方倍
  /
  else if (c <= sc || n >= MAXIMUM_CAPACITY) {
  break; //退出扩张
  }
  else if (tab == table) {
  int rs = resizeStamp(n);
  /
• 如果正在扩容Table的话，则帮助扩容
• 否则的话，开始新的扩容
• 在transfer操作，将第一个参数的table中的元素，移动到第二个元素的table中去，
• 虽然此时第二个参数设置的是null，但是，在transfer方法中，当第二个参数为null的时候，
• 会创建一个两倍大小的table
  /
  if (sc < 0) {
  Node<K,V>[] nt;
  if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
  sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
  transferIndex <= 0)
  break;
  /
• transfer的线程数加一,该线程将进行transfer的帮忙
• 在transfer的时候，sc表示在transfer工作的线程数
  /
  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);
  }
  }
  }
  }

在tryPresize方法中，并没有加锁，允许多个线程进入，如果数组正在扩张，则当前线程也去帮助扩容。

addCount方法

rivate 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)) { // counterCells不为空或者比较交换失败
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))) { // cas
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();
}
}
}

此函数主要完成binCount的值加1的操作。

扩容方法

jdk1.8transfer方法

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) //MIN_TRANSFER_STRIDE 用来控制不要占用太多CPU
stride = MIN_TRANSFER_STRIDE; // subdivide range //MIN_TRANSFER_STRIDE=16
/*

• 如果复制的目标nextTab为null的话，则初始化一个table两倍长的nextTab
• 此时nextTable被设置值了(在初始情况下是为null的)
• 因为如果有一个线程开始了表的扩张的时候，其他线程也会进来帮忙扩张，
• 而只是第一个开始扩张的线程需要初始化下目标数组
  /
  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;
  /
• 创建一个fwd节点，这个是用来控制并发的，当一个节点为空或已经被转移之后，就设置为fwd节点
• 这是一个空的标志节点
  /
  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); //设置sizeCtl为扩容后的0.75
  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) //数组中把null的元素设置为ForwardingNode节点(hash值为MOVED[-1])
  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) { //该节点的hash值大于等于0，说明是一个Node节点
  /
• 因为n的值为数组的长度，且是power(2,x)的，所以，在&操作的结果只可能是0或者n
• 根据这个规则

•     0-->  放在新表的相同位置
  

•     n-->  放在新表的（n+原来位置）
  

/
int runBit = fh & n;
Node<K,V> lastRun = f;
/

• lastRun 表示的是需要复制的最后一个节点
• 每当新节点的hash&n -> b 发生变化的时候，就把runBit设置为这个结果b
• 这样for循环之后，runBit的值就是最后不变的hash&n的值
• 而lastRun的值就是最后一次导致hash&n 发生变化的节点(假设为p节点)
• 为什么要这么做呢？因为p节点后面的节点的hash&n 值跟p节点是一样的，
• 所以在复制到新的table的时候，它肯定还是跟p节点在同一个位置
• 在复制完p节点之后，p节点的next节点还是指向它原来的节点，就不需要进行复制了，自己就被带过去了
• 这也就导致了一个问题就是复制后的链表的顺序并不一定是原来的倒序
  /
  for (Node<K,V> p = f.next; p != null; p = p.next) {
  int b = p.hash & n; //n的值为扩张前的数组的长度
  if (b != runBit) {
  runBit = b;
  lastRun = p;
  }
  }
  if (runBit == 0) {
  ln = lastRun;
  hn = null;
  }
  else {
  hn = lastRun;
  ln = null;
  }
  /
• 构造两个链表，顺序大部分和原来是反的
• 分别放到原来的位置和新增加的长度的相同位置(i/n+i)
  /
  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)
  /
• 假设runBit的值为0，
• 则第一次进入这个设置的时候相当于把旧的序列的最后一次发生hash变化的节点(该节点后面可能还有hash计算后同为0的节点)设置到旧的table的第一个hash计算后为0的节点下一个节点
• 并且把自己返回，然后在下次进来的时候把它自己设置为后面节点的下一个节点
  /
  ln = new Node<K,V>(ph, pk, pv, ln);
  else
  /
• 假设runBit的值不为0，
• 则第一次进入这个设置的时候相当于把旧的序列的最后一次发生hash变化的节点(该节点后面可能还有hash计算后同不为0的节点)设置到旧的table的第一个hash计算后不为0的节点下一个节点
• 并且把自己返回，然后在下次进来的时候把它自己设置为后面节点的下一个节点
  /
  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;
  }
  }
  /
• 在复制完树节点之后，判断该节点处构成的树还有几个节点，
• 如果≤6个的话，就转回为一个链表
  */
  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.把数组中的节点复制到新的数组的相同位置，或者移动到扩张部分的相同位置

2.在这里首先会计算一个步长，表示一个线程处理的数组长度，用来控制对CPU的使用，

3.每个CPU最少处理16个长度的数组元素,也就是说，如果一个数组的长度只有16，那只有一个线程会对其进行扩容的复制移动操作

4.扩容的时候会一直遍历，直到复制完所有节点，每处理一个节点的时候会在链表的头部设置一个fwd节点，这样其他线程就会跳过他，

5.复制后在新数组中的链表不是绝对的反序的

get方法

get方法很简单，支持并发操作，也不加锁

1.当key为null的时候回抛出NullPointerException的异常

2.get操作通过首先计算key的hash值来确定该元素放在数组的哪个位置

3.然后遍历该位置的所有节点

4.如果存在返回值，如果不存在的话返回null

public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 计算key的hash值
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) { // 表不为空并且表的长度大于0并且key所在的桶不为空
if ((eh = e.hash) == h) { // 表中的元素的hash值与key的hash值相等
if ((ek = e.key) == key || (ek != null && key.equals(ek))) // 键相等
// 返回值
return e.val;
}
else if (eh < 0) // 结点hash值小于0
// 在桶（链表/红黑树）中查找
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) { // 对于结点hash值大于0的情况
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}

size方法

size源码

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

最大值是 Integer 类型的最大值，但是 Map 的 size 可能超过 MAX_VALUE， 所以还有一个方法 mappingCount()，JDK 的建议使用 mappingCount() 而不是size()。

mappingCount() 的代码如下：

public long mappingCount() {
long n = sumCount();
return (n < 0L) ? 0L : n; // ignore transient negative values
}

以上可以看出，无论是 size() 还是 mappingCount(), 计算大小的核心方法都是 sumCount()。

sumCount() 的代码如下:

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;
}

分析一下 sumCount() 代码。ConcurrentHashMap 提供了 baseCount、counterCells 两个辅助变量和一个 CounterCell 辅助内部类。

sumCount() 就是迭代 counterCells 来统计 sum 的过程。

put 操作时，肯定会影响 size()，在 put() 方法最后会调用 addCount() 方法。

addCount() 中有如下代码：

如果 counterCells == null, 则对 baseCount 做 CAS 自增操作。

if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;

如果并发导致 baseCount CAS 失败了使用 counterCells。

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

如果counterCells CAS 失败了，在 fullAddCount 方法中，会继续死循环操作，直到成功。

private final void fullAddCount(long x, boolean wasUncontended) {
int h;
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;😉 {//死循環，直到成功
CounterCell[] as; CounterCell a; int n; long v;
if ((as = counterCells) != null && (n = as.length) > 0) {
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to atta
…

然后，CounterCell 这个类到底是什么？我们会发现它使用了 @sun.misc.Contended 标记的类，内部包含一个 volatile 变量。

@sun.misc.Contended 这个注解标识着这个类防止需要防止 “伪共享”。那么，

什么又是伪共享呢？

缓存系统中是以缓存行（cache line）为单位存储的。

缓存行是2的整数幂个连续字节，一般为32-256个字节。最常见的缓存行大小是64个字节。

当多线程修改互相独立的变量时，如果这些变量共享同一个缓存行，就会无意中影响彼此的性能，这就是伪共享。 CounterCell 代码如下：

@sun.misc.Contended static final class CounterCell {
volatile long value;
CounterCell(long x) { value = x; }
}

JDK1.8 size 是通过对 baseCount 和 counterCell 进行 CAS 计算，最终通过 baseCount 和 遍历 CounterCell 数组得出 size。

JDK 8 推荐使用mappingCount 方法，因为这个方法的返回值是 long 类型，不会因为 size 方法是 int 类型限制最大值。

remove方法

先調用remove方法

在方法內調用replaceNode方法

public V remove(Object key) {
return replaceNode(key, null, null);
}

replaceNode方法

final V replaceNode(Object key, V value, Object cv) {
// 计算key的hash值
int hash = spread(key.hashCode());
for (Node<K,V>[] tab = table;😉 { // 无限循环
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null) // table表为空或者表长度为0或者key所对应的桶为空
// 跳出循环
break;
else if ((fh = f.hash) == MOVED) // 桶中第一个结点的hash值为MOVED
// 转移
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) { // 加锁同步
if (tabAt(tab, i) == f) { // 桶中的第一个结点没有发生变化
if (fh >= 0) { // 结点hash值大于0
validated = true;
for (Node<K,V> e = f, pred = null;😉 { // 无限循环
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) { // 结点的hash值与指定的hash值相等，并且key也相等
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) { // cv为空或者与结点value相等或者不为空并且相等
// 保存该结点的val值
oldVal = ev;
if (value != null) // value为null
// 设置结点value值
e.val = value;
else if (pred != null) // 前驱不为空
// 前驱的后继为e的后继，即删除了e结点
pred.next = e.next;
else
// 设置table表中下标为index的值为e.next
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

98fc271b5b41.jpeg)

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）
[外链图片转存中…(img-ayOgY94D-1713309779953)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！