本文已参与「新人创作礼」活动，一起开启掘金创作之路。
大家好，这里是追風者，今天来聊一聊并发容器 ConcurrentHashMap。
ConcurrentHashMap 是线程安全的，内部维护了一维数组，当单个桶中的元素超过 8 个的时候，会考虑进行数组扩容，当数组长度大于等于 64且单个桶内元素超过 8 个，可以考虑链表转换为红黑树。普通情况下的扩容会将数组扩容为原先的二倍。最后要说一下 sizeCtl 属性，平时表示扩容阈值，sizeCtl 为 -1 表示数组初始化，sizeCtl 为 -2 表示扩容，在节点迁移时期，sizeCtl 第 16 位表示有多少线程在进行迁移。它的数据结构如下图所示。
由于 ConcurrenthashMap 一共有六千多行代码，没必要全部看完，本文主要了解 ConcurrentHashMap 的模型，对插入/删除 元素进行分析，但这也包括了扩容、节点迁移、树化等操作了，干货满满。
由于代码中无法使用锚点，将方法设为标题了，直接按照目录跳转方法即可（也可以根据 IDEA 中的源码来比对，我是 JDK8）。
一定要带数据跟着方法走，不能直接按顺序去看，比如看 ReeterLock 源码时，获取锁阻塞后，尽量直接去看释放锁的代码，要有思维的连贯性。
put()
put() 方法的总思想：计算插入元素的 hash 值，通过路由算法 (n-1) & hash 来定位元素应该插入的位置，然后判断桶中是否有元素，如果是链表就不断比最后较插入链表尾部（相同就根据 onlyIfAbsent 的值判定是否替换，默认不替换）。如果桶中是 TreeBin 节点，就将元素转化为 TreeNode 插入到红黑树中（会包含旋转平衡）。如果桶中元素的 hash 为 -1（表示当前桶迁移完毕了），就帮助其进行节点迁移。最后插入完毕后，binCount 会记录该桶中的元素数量，大于等于 8 就进行扩容操作（如果 siezeCtl 大于 0 并且 ConcurrentHashMap 中元素个数大于 sizeCtl 时，也会触发扩容操作）。当数组长度大于等于 64且单个桶内元素超过 8 个，就会将链表转换为红黑树。
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// ConcurrentHashMap 不允许 key 或 value 为空，HashMap 是允许的。
if (key == null || value == null) throw new NullPointerException();
// 通过 key 的 hashCode 计算 key 的 hash
// spread() (h ^ (h >>> 16)) & HASH_BITS
// h 异或 h 无符号右移 16 位，将高 16 位特性嫁接到低 16 位。
// 因为 int 占 32 位，但有一个符号位，所以 HASH_BITS 为 31 位 1。
// 后面 (n - 1) & hash 为路由算法（定位桶索引），一般情况下只能用到 hash 的低 16 位。
// 将高低属性属性嫁接后，不容易发生碰撞。
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)
// 桶数组无数据时，初始化数组
// 如果没有给 sizeCtl 加载因子赋值，默认是数组长度的 3/4, 12
tab = initTable();
// (n - 1) & hash 就是因为这个路由算法，ConcurrentHashMap 必须是 2 的次幂。
// 当 n 为 2 次幂时，n-1 的二进制就全是 1，能够有效获得 hash 的特点，使其散列。
// tabAt(tab, i) 获取内存中 tab 数组 i 索引的数据
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 若找到的桶无数据
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null))) // 对该桶进行CAS赋值
break; // no lock when adding to empty bin
}
// f 为选定的桶，如果 桶中节点的 hash 为 MOVED，表示该桶及其元素是迁移完毕的。
else if ((fh = f.hash) == MOVED) // 当前位置有数据 且 hash值 是 -1（迁移完毕）
tab = helpTransfer(tab, f);
else {
// 桶里面有元素，需要拉链表了。
V oldVal = null;
// 对 桶中元素 加锁
synchronized (f) {
// tabAt() 从内存上获取 tab[i]，即判定 f 为桶中节点
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 若有相同的key，根据 布尔值选择是否替换。
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;
// 此处是 链表式 插入
// 如果 e 后面无节点，直接插入到 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;
// 如果 p != null，就是找到相等的节点了，否则就是插入成功了。
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) // ConcurrentHashMap 桶 中的元素数量超过 8
// 扩容或转化红黑树
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 插入了一个元素，baseCount 或者 counterCells 某元素 +1
addCount(1L, binCount);
return null;
}
initTable()
initTable() 初始化数组
// 初始化数组
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 因为siceCtl为数组初始容量，在构造函数中进行赋值，必须为 2 的幂数。
// 初始 sizeCtl 为0.
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin 暂停当前线程，放弃CPU资源，执行其他线程
// CAS 操作，将 sc 赋值为 -1
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
// 如果 sc 大于0，表示有一个合理的初始值，就为 n 赋值，否则给默认的初始值 16。
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// sc 为 数组的 3/4
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
tabAt()
//内存上定位数组元素
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
// ASHIFT 数组类型的最高位 ABASE 数组第一个元素的地址偏移量
// ((long)i << ASHIFT) + ABAS 寻址方式 类似于数组寻址方式 数组起始地址 + 索引 * 数组类型空间大小
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
casTabAt()
// CAS 替换数组元素
// ASHIFT 为偏移量，ABASE 为起始地址。 通过 起始地址 + 偏移量 * 每个元素的大小 获取到的就是 ASHIFT 个元素的内存起始地址。
// Unsafe 都是进行内存单元操作。
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
helpTransfer()
helpTransfer() 方法是帮助进行扩容迁移。
// f 是表示扩容完毕的桶
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// ForwardingNode 是在转移操作完毕时，在仓头插入的节点。
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// resizeStamp() 将 tab.length 二进制最高位前面有多少个 0 记作 n,
// 将 n 第 15 位置 1
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
// 调用迁移方法 transafe 前，都会将 sizeCtrl 赋值负数
// U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)
(sc = sizeCtl) < 0) {
// sc 无符号右移 16 位
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
// 扩容接近尾声的时候， transferIndex == 0 可以发生，表示有线程要扩容进行到 0了。
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)
// CAS 将 sizeCtl + 1，表示有多少个线程在进行扩容。
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 从 helpTransfer 进入，迁移结束后，会返回此处，直接 break。
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
putTreeVal()
// 红黑树 查找或插入
final TreeNode<K,V> putTreeVal(int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 首次插入，直接设置为 root 节点
if (p == null) {
first = root = new TreeNode<K,V>(h, k, v, null, null);
break;
}
else if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// 当 插入的 key 与 树节点 key 相同时，直接返回
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
// 进入该判定表示新插入的节点通过 compareTo 无法进行比较。
// 到此处 hash 相等，但 key 不相等
else if ((kc == null &&
// (kc = comparableClassFor(k)) == null) 表示 k 没有实现 Comparable 接口
(kc = comparableClassFor(k)) == null) ||
// 因为 kc 是 k 的类对象。 compareComparables(kc, k, pk)
// 如果 k 与 pk 是同一类型，就返回 compareTo 的比较值，反之就返回 0。
(dir = compareComparables(kc, k, pk)) == 0) {
// 通过 searched 来进行判定，只能进入一次。
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
// 通过左右子树查找，
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;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// first 为链表首部 first 是按照插入顺序的链表
TreeNode<K,V> x, f = first;
// TreeNode(int hash, K key, V val, Node<K,V> next, TreeNode<K,V> parent)
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;
}
findTreeNode()
// 如果找到相同节点，就返回节点，否则返回 null
final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
if (k != null) {
// 此处的 this 指向的是 调用 findTreeNode 方法的节点
// 即 如果 r.findYreeNode 此处的 this 就代表 r
TreeNode<K,V> p = this;
do {
int ph, dir; K pk; TreeNode<K,V> q;
TreeNode<K,V> pl = p.left, pr = p.right;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.findTreeNode(h, k, kc)) != null)
return q;
else // 由于上面使用了 pr 作为查找并且没有找到，此处就使用 pl 直接进行查找。
p = pl;
} while (p != null);
}
return null;
}
}
comparableClassFor()
// 如果对象 x 的类 C 实现了接口 Comparable，并且泛型为 C，就返回 x 运行时类型。
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
tieBreakOrder()
tieBreakOrder() 方法是在无法通过比较器将两个元素进行比较时，重新生成 hashCode 进行比较。
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
// System.identityHashCode 为对象重新生成 hashCode，即使对象一致，两次调用的 hashCode 也不一致，保证有个返回值
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
lockRoot()
lockRoot() 对根节点进行上锁。
private final void lockRoot() {
if (!U.compareAndSwapInt(this, LOCKSTATE, 0, WRITER))
// 获取写锁失败，将当前线程阻塞，并将 waiter 设置为当前线程。
contendedLock(); // offload to separate method
}
balanceInsertion()
红黑树旋转平衡。
/**
* 红黑树的旋转平衡
*
* <p>左旋：以某个节点作为旋转节点，其右子节点变为旋转节点的父节点，右子节点的左子节点变为旋转节点的右子节点。</p>
* <p>左旋简便记忆法：将右手大拇指点在旋转节点，二拇指点在旋转节点的右子节点，中指点在旋转节点的右子节点的左子节点，逆时针旋转即可。</p>
*
* <p>右旋：以某个节点作为旋转节点，其左子节点变为旋转节点的父结点，左子节点的右子节点变为旋转节点的左子节点。</p>
* <p>右旋简便记忆法：将右手中指点在旋转节点，二拇指点在旋转节点的左子节点，大拇指点在旋转节点的左子节点的右子节点，顺时针旋转即可。</p>
*
* <p>插入节点的父节点为黑色，不影响红黑树的黑高性质；</p>
* <p>插入节点的父节点为红色：</p>
* <p>1. 叔叔节点存在且为红色节点（因为红红不能相连，所以爷爷节点为黑色）：
* 将叔叔节点与父亲节点变更为黑色。
* 爷爷节点变为红色。
* 爷爷成为当前节点，进行后续操作（看双红为哪种情况）。</p>
* <p>2. 叔叔节点不存在/为黑色结点，并且插入节点的父亲结点是爷爷结点的左子结点：
* 但是按照红黑树的黑高性质，叔叔结点只能是不存在。</p>
* <p>2.1 插入结点为父亲结点的左子节点（LL双红）：
* 将父节点设置黑色，将爷爷结点设置红色。
* 将爷爷结点进行右旋。</p>
* <p>2.2 插入结点为父亲结点的右子节点（LR双红）：
* 对父节点进行左旋。
* 变为LL双红情况进行处理。</p>
* <p>3. 叔叔节点不存在/为黑色结点，并且插入节点的父亲结点是爷爷结点的右子结点：</p>
* <p>3.1 插入结点为父亲结点的右子节点（RR双红）：
* 将父节点设置黑色，将爷爷结点设置红色。
* 将爷爷结点进行左旋。</p>
* <p>3.2 插入结点为父亲结点的左子节点（RL双红）：
* 对父节点进行右旋。
* 变为RR双红情况进行处理。</p>
*/
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true;
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
// 无父结点为根节点，必须为黑色
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
// 父结点为黑色，或者父结点为黑色但其为根节点。
else if (!xp.red || (xpp = xp.parent) == null)
return root;
// 父结点为 爷爷节点的左子节点。
if (xp == (xppl = xpp.left)) {
// xppr 叔叔节点存在，是爷爷的右子节点，为红色 此为情况 1
if ((xppr = xpp.right) != null && xppr.red) {
// 将父亲节点、叔叔节点变色为黑色。爷爷节点变为红色。
xppr.red = false;
xp.red = false;
xpp.red = true;
// 将 x 指向爷爷节点，循环变色。
x = xpp;
}
// xxpr 叔叔节点不存在，那么就要解决双红问题了
else {
// 插入的节点是父结点的右子节点 LR 双红，对父节点左旋
if (x == xp.right) {
// 对父结点左旋操作
root = rotateLeft(root, x = xp);
// 向上提一层，进行迭代
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
// 右旋
root = rotateRight(root, xpp);
}
}
}
}
// 父结点为 爷爷节点的右子节点
else {
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
// RL
if (x == xp.left) {
// 先右旋
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateLeft(root, xpp);
}
}
}
}
}
}
rotateLeft()
对父结点左旋操作。
/**
* 左旋平衡
*
* ○ pp ○ pp
* \ \
* ○ -- > 此为旋转节点 p ○ r
* \ / \
* ○ r 此为旋转节点 p -- > ○ ○
* / \ -------> \
* rl ○ ○ ○ rl
* / \ / \
* ○ ○ ○ ○
*
*/
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> r, pp, rl;
if (p != null && (r = p.right) != null) {
if ((rl = p.right = r.left) != null)
rl.parent = p;
if ((pp = r.parent = p.parent) == null)
(root = r).red = false;
else if (pp.left == p)
pp.left = r;
else
pp.right = r;
r.left = p;
p.parent = r;
}
return root;
}
rotateRight()
右旋平衡。
/**
* 右旋平衡
*
* ○ pp ○ pp
* \ \
* ○ -- > 此为旋转节点 p ○ l
* / / \
* ○ l ○ ○ --> p
* / \ -------> /
* ○ ○ lr ○ lr
* / \ / \
* ○ ○ ○ ○
*
*/
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> l, pp, lr;
if (p != null && (l = p.left) != null) {
if ((lr = p.left = l.right) != null)
lr.parent = p;
if ((pp = l.parent = p.parent) == null)
(root = l).red = false;
else if (pp.right == p)
pp.right = l;
else
pp.left = l;
l.right = p;
p.parent = l;
}
return root;
}
treeifyBin()
// 扩容或转化红黑树
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
// 如果数组的长度 小于 最小树化阈值 64
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 数组扩容 为原先二倍，最后可能是原本的四倍
// n 在 tab 初始化时为 16，传入 32
tryPresize(n << 1);
// 此处需要构建树了
// index 为桶索引
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {
if (tabAt(tab, index) == b) {
// hd head; tl tail
TreeNode<K,V> hd = null, tl = null;
// 构建 TreeNode 的链表....
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)
hd = p;
else
tl.next = p;
tl = p;
}
// 将构建好的红黑树，封装为 TreeBin 对象放在桶中。
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
tryPresize()
// 数组扩容，并进行节点迁移
private final void tryPresize(int size) {
// 计算扩容后的数组大小
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
// 计算数组扩容后的大小 1.5 倍，最后扩到 2 的次幂
// 32 + 16 + 1 = 46
// tableSizeFor = 64
tableSizeFor(size + (size >>> 1) + 1);
int sc;
// 第一次扩容， sc = sizeCtl = 12
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
// 数组为空或数组的长度为 0 ？？？
if (tab == null || (n = tab.length) == 0) {
// 获取相对较大的作为数组的长度。
n = (sc > c) ? sc : c;
// CAS 从内存上替换 sizeCtl 为 -1，表示在进行迁移。
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
// 创建一个新的长度的数组。
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
// sc 再次设置为 3/4 n
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) {
// n 是数组长度， rs 是 n 的第15位置 1 了
int rs = resizeStamp(n);
// sc = -1 时，数组正在被创建。
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;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// CAS 将 sizeCtl 替换为 数组长度左移 16 位 + 2
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 进行节点迁移
transfer(tab, null);
}
}
}
tableSizeFor()
计算扩容后的数组大小
/**
* c = 9
* n = 8
*
* 0000 0000 0000 0000 0000 0000 0000 1000 n --> 8
* 0000 0000 0000 0000 0000 0000 0000 0100 n >>> 1
* ------------------------------------------------
* 0000 0000 0000 0000 0000 0000 0000 1100 n
* 0000 0000 0000 0000 0000 0000 0000 0011 n >>> 2
* -----------------------------------------------
* 0000 0000 0000 0000 0000 0000 0000 1111 n
* 后面按位或就无效了。
*
* 多次的位运算，将 n 二进制最高位 1 后面全部置 1
* 当 c 为9 时，n 为 8
* 通过多次的 按位或运算后 n --> 0000 0000 0000 0000 0000 0000 0000 1111
* 最后返回 n + 1 为 16 保证了是 2 的次幂
*/
private static final int tableSizeFor(int c) {
// 此处将 c - 1 操作，防止当 c 本身是 2 的次幂时，运算后还会大出一个数量级。
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
resizeStamp()
将传入的参数，第 15 位置 1。
static final int resizeStamp(int n) {
// numberOfLeadingZeros 方法计算的是 n 转为二进制，最高位前面有多少 0
// 如果 n 为8，Integer.numberOfLeadingZeros(n) 为 24
// 0000 0000 0000 0000 0000 0000 1001 1111 | 0000 0000 0000 0000 1000 0000 0000 0000
// 0000 0000 0000 0000 1000 0000 1001 1111
// 将第 15 位置 1
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
transfer()
// 迁移
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
// 第一次 n 为 16
int n = tab.length, stride;
// stride 最小为 16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 初始化出 newTab 数组，长度为 tab 的 二倍
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;
// 将迁移数组头部加上 ForwardingNode 节点
// 当桶中存储的是 ForwardingNode 节点时，表示该桶已经扩容完毕，无需再次扩容
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 迁移标志位 advance 迁移进行中 finishing 迁移结束
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;
// 第一次进入，不执行
// 第二次进入，i = 15，--i 后为 14，bound ~ i 逐个桶进行扩容迁移。
if (--i >= bound || finishing)
advance = false;
// nextIndex = 16
// transferIndex 最小 为 0
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// CAS nextIndex = nextIndex - stride
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// bound = 0
bound = nextBound;
// i = 15
i = nextIndex - 1;
advance = false;
}
}
//
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 将 tab 修改为 nextTab，将 nextTable 置空。
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// CAS 使 sizeCtl - 1, sc = 12
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 进入 transfer 方法前
// U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)
// 当 sc - 2 与 resizeStamp(n) << RESIZE_STAMP_SHIFT 相等，表示扩容彻底结束
// 如果 sc -2 与 resizeStamp(n) << RESIZE_STAMP_SHIFT 不等，返回后循环还会进入 tranfer
// 如果是从 helpTransfer 进入的 transfer 方法，直接就返回。
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
// tabAt(tab, i) 获取到 tab[i] 赋值给 f
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// f 的 hash 为 -1
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) {
// 此时 n 为 16
// runBit = x & 0000 0000 0000 0000 0000 0000 0001 0000
// 只保留 第 5 位
int runBit = fh & n;
Node<K,V> lastRun = f;
// for 循环出来后，runBit 是最后一个与上一个 lastRun hash&n 不同的值
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
// 一组 if-else 判断，
// ln 收录的是 hash判定为 0 的
// hn 收录的是 hash判定为 1 的
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
// 将hash判定为 0 的节点，放入 ln 链表 头插链表
// 将hash判定为 1 的节点，放入 hn 链表
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)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 将两组链表分别放入 新数组 i 和 i+n 的索引处。
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);
// hash判定为 0 时，p 进入到 lo 链表
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
// hash判定为 1 时，p 进入到 hi 链表
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
// 如果 lc 小于 UNTREEIFY_THRESHOLD（6），就按照链表进行存储。
// untreeify(lo) 将 lo 链表以 Node 节点进行展示。
// 如果 lc 大于 6，就将 hi 包装为 TreeBin 对象存入桶中。
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;
}
}
}
}
}
}
TreeBin()
创建 TreeBin 对象。
// 根据 TreeNode 链表构建红黑树。
TreeBin(TreeNode<K,V> b) {
super(TREEBIN, null, null, null);
this.first = b;
TreeNode<K,V> r = null;
for (TreeNode<K,V> x = b, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
// r 为 root 根节点，必须为黑色来保证黑高的性质。
if (r == null) {
x.parent = null;
x.red = false;
r = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = r;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// 此处，hash 为相等
else if ((kc == null &&
// comparableClassFor k 如果实现了 comparable 接口并且泛型定义为 k 的类，返回其类。
(kc = comparableClassFor(k)) == null) ||
// 如果 k 和 pk 无法进行比较，就会 等于 0
(dir = compareComparables(kc, k, pk)) == 0)
// 只能通过类名进行比较了 tieBreakOrder。类名比较不出就重新生成 hashCode 的方式，进行比较。
dir = tieBreakOrder(k, pk);
// 下面方法不在 else-if 方法体内
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 调整平衡
r = balanceInsertion(r, x);
break;
}
}
}
}
this.root = r;
assert checkInvariants(root);
}
addCount()
将标识 ConcurrentHashMap 中元素数量的值增加。
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if ((as = counterCells) != null ||
// baseCount 从 0 开始，s = 1
// baseCount 被 volatile 修饰，为什么会失败？
// baseCount 是被 long 修饰的，多线程竞争，可能 volatile 无法保证其原子性
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
// 第一次 as 为 null 时，会将后续操作短路， as.length - 1 也就执行不到了，不会空指针！
// 第二次 m = 1
if (as == null || (m = as.length - 1) < 0 ||
// 如果 as[*] 为 null，调用 fullAddCount(x, true) 为 as[*] 赋值。
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
// 修改 counterCells 数组中的数据，更新为 v + x.
// 如果此时又出现原子性竞争失败，进入 fullAddCount(x, false) 为 as[*] 修改值
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
// counterCells 所有元素 value + baseCount
s = sumCount();
}
// counterCells 为 空，且 CAS baseCount 成功了。
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// s 为节点数
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 将 n 第 15 位置 1
int rs = resizeStamp(n);
// 如果 sc<0 表示表在扩容中
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();
}
}
}
get()
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
// e 为桶元素
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// TreeBin 的 hash 为 -2
else if (eh < 0)
// 注意：此处进入的是 TreeBin 的 find！！！
// 默认进入的第一层 find 是 Node 节点的。
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
final Node<K,V> find(int h, Object k) {
if (k != null) {
// first 是顺序链表
for (Node<K,V> e = first; e != null; ) {
int s; K ek;
// 当 lockState 为 0 时，按位与运算 == 0，当 有线程将根节点锁住时，只能按照链表查。
if (((s = lockState) & (WAITER|WRITER)) != 0) {
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
e = e.next;
}
else if (U.compareAndSwapInt(this, LOCKSTATE, s,
s + READER)) {
TreeNode<K,V> r, p;
try {
p = ((r = root) == null ? null :
// 树查询
r.findTreeNode(h, k, null));
} finally {
Thread w;
// LOCKSTATE = LOCKSTATE + (-READE) 即 复原了
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}
注
通过上面的源码分析，大家一定对 ConcurrentHashMap 的结构大体有了了解，窥斑见豹，相信对 ConcurrentHashMap 的结构有了了解后，后期使用不成问题了，大家可以自行钻研其它的方法。
如果文章有任何错误欢迎各位斧正，编程心得就是需要不断的交流才会拓宽视野，感谢各位。
