文章目录
前言
本次内容基于JDK11.0的源码进行解析
一、数据结构
这里首先说一下ConCurrentHashMap的数据结构，在JDK1.8之后数据结构主要为：数组+链表+红黑树，如下图：
其中绿色节点代表链表、黑色节点代表红黑树的根节点，大家先对整个数据结构有个大体的了解，下面我们将从存入数据和获取数据两方面来详细解析ConcurrentHashMap的源码。
二、初始化操作
在开始解析存入数据和获取数据之前，先来看一下ConcurrentHashMap的初始化操作:
// 第一种：带参数的构造方法
ConcurrentHashMap<String, Object> concurrentHashMap = new ConcurrentHashMap<>(8);
concurrentHashMap.put("hello", "world");
// 第二种：空参构造方法
ConcurrentHashMap<String, Object> hashMap = new ConcurrentHashMap<>();
hashMap.put("hello", "ConcurrentHashMap");
这里主要列举两种比较常用的构造ConcurrentHashMap的方法，可以看出，两种构造方法的主要区别是：第一种比二种多了一个参数，这个参数的作用是定义数组的初始化大小。下面看一下构造方法里面具体是怎么做的：
第一种：
public ConcurrentHashMap(int initialCapacity) {
this(initialCapacity, LOAD_FACTOR, 1);
}
这里可以看到内部实际上是调用了一下三个参数的构造方法。具体为参数为：initialCapacity（数组的初始化大小），LOAD_FACTOR（负载因子）及一个常量1（预计访问和更新数据的线程数）。
//PS：这里先单独说一下LOAD_FACTOR，可以看到负载因子的默认值为0.75，大家先记住这个值
// 这个值很重要，它决定了后续我们数组扩容的阈值，后面会详细说一下。
//（至于为什么默认值是0.75，这里主要是根据泊松分布的算法计算出来的，感兴趣的可以自己查一下）
private static final float LOAD_FACTOR = 0.75f;
看一下内部具体又做了什么：
public ConcurrentHashMap(int initialCapacity,float loadFactor,int concurrencyLevel){
// 对参数进行校验，负载因子不可以<=0, 数组的初始化长度不可<0, 线程数不可以<0
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// 判断如果初始化数组的长度不能小于线程数
if (initialCapacity < concurrencyLevel)
// 如果小于线程数，就把线程数的值赋给数组的初始化大小
initialCapacity = concurrencyLevel;
// 根据负载因子计算一个size，注意这里计算的不是最终的数组大小，只是先计算一个大概值；
// eg：initialCapacity = 8时，size = 1 + 8 / 0.75 = 11
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
// 校验一下计算出来的大概值，如果大于最大的值，就取最大值，
// 如果没大于最大值，则获取tableSizeFor((int)size)
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
// 将最终的数组大小赋值给sizeCtl（这个全局变量及其重要）
this.sizeCtl = cap;
}
这里有两个比较重要的点单独说一下：
1、sizeCtl：这个参数特别重要，后来的扩容，转红黑树、等操作都需要依赖这个参数。
// 表示当前Hash位置的数据正在扩容
static final int MOVED = -1;
// 表示当前Hash位置下挂载的是红黑树
static final int TREEBIN = -2;
// 表示占用当前索引位置
static final int RESERVED = -3;
sizeCtl = -1 时，代表正在初始化；
sizeCtl < -1 时，低16位代表当前数组正在扩容的线程个数（如果一个线程扩容则值为2，如果两个线程扩容为3）；
sizeCtl = 0 时，代表数组还未初始化
sizeCtl > 0 时，代表当前数组的扩容阈值或者是当前数组的初始化大小
2、tableSizeFor((int)size)：这个方法的作用使用来获取离size最近的2的n次幂的数作为数组的长度，这个方法后续扩容的时候还会用到，所以我们这里先看一下：
// 经过上面的计算c = 11
private static final int tableSizeFor(int c) {
// 这里用二进制计算：
// c = 00000000 00000000 00000000 00001011
// c - 1 = 00000000 00000000 00000000 00001010 (十进制：10)
// 这里c-1主要是为了避免如果c正好是2的n次幂的话，会导致右移动时多计算一位到值整个的数组大小扩大了一倍
int n = -1 >>> Integer.numberOfLeadingZeros(c - 1);
// -1 >>> 28 = 0000 0000 0000 0000 0000 0000 0000 1111 （二进制：15）
// 最后返回：16
// -1>>>的操作后会导致移动位数都是0，后面都是1，+1正好可以获取到最接近的2的n次幂的数
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
// i = 00000000 00000000 00000000 00001010 (十进制：10)
public static int numberOfLeadingZeros(int i) {
// 判断 i 是否 <= 0，若 == 0 则给默认值32，否者返回0
if (i <= 0)
return i == 0 ? 32 : 0;
// 定义 变量 n = 31 ，因为32位的int最高位是符号位，所以我们先计算除了符号位的
int n = 31;
// 1 << 16 = 00000000 00000001 00000000 00000000
if (i >= 1 << 16) { n -= 16; i >>>= 16; }
// 1 << 8 = 00000000 00000000 000000001 00000000
if (i >= 1 << 8) { n -= 8; i >>>= 8; }
// 1 << 4 = 00000000 00000000 00000000 00010000
if (i >= 1 << 4) { n -= 4; i >>>= 4; }
// 1 << 2 = 00000000 00000000 00000000 00000100
if (i >= 1 << 2) {
// 符合该区间
// 计算后 n = 29
// i = 00000000 00000000 00000000 00000010 (十进制：2)
n -= 2;
i >>>= 2;
}
// n - （i >>> 1）= 28
return n - (i >>> 1);
}
这里的计算主要目的就是保证我们输入的任何数，都可以变成离它最近的2的n次幂，来保证我们数组的大小一都是2的n次幂。
三、存入数数据
先看一下存入数据的方法：
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 首先能看到第一行，ConcurrentHashMap的key和value是不允许为null的
if (key == null || value == null) throw new NullPointerException();
// 这里是开始计算当前插入key的hash值，下面会详细的分析spread(key.hashCode())；
int hash = spread(key.hashCode());
// 这里先定义一个计数器
int binCount = 0;
// 开始循环，这里是一个死循环
for (Node<K,V>[] tab = table;;) {
// 定义一堆变量
// n: 数组长度
// i: 当前node需要存放的索引位置
// fh: 当前数组索引i位置上的hash值
// f: 当前数组i索引位置上的node节点
Node<K,V> f; int n, i, fh; K fk; V fv;
// 判断是否初始化
if (tab == null || (n = tab.length) == 0)
// 初始化数组
tab = initTable();
// 计算在数组上所在的下标位置的node节点，并赋值给f
// 将计算的index下标赋值给i
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果进入这里说明，所在位置为null，直接通过CAS的形式插入数据
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break;
}
// 说明该位置已经有数据，并将该节点的hash值赋值给fh，判断如果为-1说明正在扩容
else if ((fh = f.hash) == MOVED)
// 辅助扩容的方法
tab = helpTransfer(tab, f);
// 判断如果为onlyIfAbsent为true，说明不需要覆盖原值
else if (onlyIfAbsent // check first node without acquiring lock
&& fh == hash
&& ((fk = f.key) == key || (fk != null && key.equals(fk)))
&& (fv = f.val) != null)
// 如果hash值相等，并且key都相同，则直接返回当前位置的vaule
return fv;
else {
// 插入操作
V oldVal = null;
synchronized (f) {
// 再次判断，当前节点的值和f
if (tabAt(tab, i) == f) {
// 说明是链表
if (fh >= 0) {
binCount = 1;
// 循环找到key应该在hash位置
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;
// 未找到相同的，则直接挂载节点
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value);
break;
}
}
}
// 说明是红黑树
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
// 调用TreeBin的putTreeval方法
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
// 计数器判断
if (binCount != 0) {
// 若大于等于阈值：8
if (binCount >= TREEIFY_THRESHOLD)
// 里面会判断数组的长度如果小于64，则会先尝试扩容，而不会直接转为红黑树
// 所以：转为红黑树的逻辑为，链表长度大于等于8 并且数组长度大于等于64
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 基于longadder增加计数器
addCount(1L, binCount);
return null;
}
可以看到上面就是putVal的大体逻辑，有几个比较重要的点，单独梳理一下：
1.spread方法
// 二进制：01111111 1111111 1111111 1111111
// 作用是：作用是保证最后的结果高位一定是0，一定是正数；因为hash值为负数时有特殊含义
static final int HASH_BITS = 0x7fffffff;
// 将hashCode的高位与低位进行异或运算
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
// eg： h = 00110010 01010100 00000110 00010100
// h >>> 16 = 00000000 00000000 00110010 01010100
// h ^ (h >>> 16) = 00110010 01010100 00110100 01000000
// & HASH_BITS = 00110010 01010100 00110100 01000000
让hashCode的高16位与低16位进行异或，主要是为解决，如果低16位相同的话，会导致计算的索引下标重复，从而不能尽可能的打散数据；例如：
hash1：00110010 01010100 00000110 00010100
hash2：00000101 01001010 00000110 00010100
hash1和hash2的低16位相同，这样会导致计算出来的hash相同从而落在数组上的同一位置，右移动16位的作用就是让高16位也参与计算，尽可能的打散数据，尽量让数据落在数组上的不同位置；高低位进行异或后 & HASH_BITS 的作用是为了保证计算出来的hash值一定是正数。
2.initTable
private final Node<K,V>[] initTable() {
// 定义两个局部变量，tab代表数组，sc代表sizeCtl
Node<K,V>[] tab; int sc;
// 将全局变量table数组赋值给局部变量tab（注意：这里第一次判断数组是否为空！！！）
while ((tab = table) == null || tab.length == 0) {
// 这里先将全局变量sizeCtl赋值给局部变量sc，并切判断是否小于0；
// 因为如果sizeCtl小于0，说明当前数组正在初始化或者正在扩容，则调用yield的方法；
// 让出当前时间片，避免一致循环占用过多资源。
if ((sc = sizeCtl) < 0)
Thread.yield();
// 通过UnSafe类CAS操作，尝试将sizeCtl设置为-1（注意：这里相当于是lock操作！！！）
else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
try {
// 再次判断数组是否为空（注意：这里是第二次判断数组是否为空！！！）
if ((tab = table) == null || tab.length == 0) {
// 判断局部变量sc是否大于0，若大于0，则说明创建map时指定了当前数组的大小；
// 若未指定，则给默认大小。
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
// 初始化数组操作
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 将初始化的数组，赋值给全局变量
table = tab = nt;
// 计算下一次需要扩容的阈值，并赋值给局部变量sc
sc = n - (n >>> 2);
}
} finally {
// 将局部变量的值，赋值给全局变量sizeCtl
sizeCtl = sc;
}
break;
}
}
// 返回数组
return tab;
}
这里有两个需要注意的点：
第一个是：可以看到，注释中有三个需要注意，三个地方的作用分别是第一次判空、CAS修改变量的值（可以视为Lock）、第二次判空，这就是保证并发下初始化数组不会出问题的原因DCL（Double Check Lock）。
第二个是：当我们new 一个ConCurrentHashMap时，我们并不会马上对数组进行初始化（懒加载），只有在第一次想数组中put数据时，才会对整个数组进行初始化。
3.helpTransfer
// 帮助扩容的方法，其中tab是老数组，f是数组上的node节点
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
// nextTab：新数组
Node<K,V>[] nextTab;
// sc：sizeCtl
int sc;
// 判断老数组不为null，全局变量新数组等于当前节点指向新数组并且不为空
if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 符合条件说明正在扩容，基于老数组长度计算扩容戳
int rs = resizeStamp(tab.length);
// 第一个判断：fwd中的新数组和当前扩容的新数组是否相等，相等：可以协助扩容，
// 不相等：要不扩容结束，要么开启新的扩容
// 第二个判断：老数组是否改变，相等：可以协助扩容，不相等，扩容结束了
// 第三个判断：如果正在扩容sizeCtl一定是负数
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 将sc右移16位，判断是否与扩容戳一致，如果不一致，说明扩容长度不一致，退出协助扩容。
// transferIndex 是从高索引位置，到低索引位置领取数据的核心属性，如果满足，小于等于0，说明任务被领光了
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 通过CAS操作低16位+1，记录并发线程数+1
if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1)) {
// 调用实际扩容方法
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
3.treeifyBin
// 链表长度大于等于8时，尝试将链表转为红黑树 tab为数组，index为当前节点的数组下标
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n;
// 判断数组不能为null
if (tab != null) {
// 判断数组的长度是否小于64，如果数组的长度小于64，不能将链表转为红黑树，先尝试扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 扩容操作 n为当前数组的长度
tryPresize(n << 1);
// 判断当前数组位置的节点是否为空并赋值给b，判断b.hash值是否大于0，如果大于0
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 锁住当前节点
synchronized (b) {
// 再次判断是否相等
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
// 开始循环，将链表上的每一个节点封装成一个双向链表
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);
// 处理prev指针，若为空说明是头节点
if ((p.prev = tl) == null)
// 将头节点赋值给hd
hd = p;
else
// 处理next指针，完成双向链表的处理
tl.next = p;
// 移动tl
tl = p;
}
// 将头节点放到数组的对应位置上
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
4.TreeBin
TreeBin(TreeNode<K,V> b) {
// 调用父类的方法构建一个TreeNode
super(TREEBIN, null, null);
// 将双向链表赋值给first属性，保存起来
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;
// 根节点，设置为黑色，parent设置为null
if (r == null) {
x.parent = null;
x.red = false;
r = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
// 循环双向链表，根据hash值判断左右
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;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
// hash值相等，调用方法计算左右
dir = tieBreakOrder(k, pk);
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);
}
5.tryPresize
// size是将之前数组的长度 << 1,得到的结果
private final void tryPresize(int size) {
// 如果扩容的长度达到了最大值的一半，则使用最大值
// 否则需要保证数组的长度为2的n次幂
// 这里的操作是为了初始化准备的，因为调用putall方法时，也会触发tryPresize方法
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
// 声明sc
int sc;
// 将sizeCtl的值赋值给sc并判断是否大于0，这里代表没有初始化也没有扩容
while ((sc = sizeCtl) >= 0) {
// 将table赋值给tab
Node<K,V>[] tab = table; int n;
// 判断是否需要初始化
if (tab == null || (n = tab.length) == 0) {
// sc是初始化长度，判断初始化长度如果大于计算出来的c，则直接使用sc，如果没有sc大
// 说明sc无法容纳下putall中传入的map，使用更大的数组长度
n = (sc > c) ? sc : c;
if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
// 如果计算出来的c如果小于sc直接退出， 或者n已经大于等于数组最大长度了，也直接退出
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
// 判断当前的tab是否和table相同
else if (tab == table) {
// 计算扩容表示戳，根据当前数组的长度，计算一个16位的扩容戳
int rs = resizeStamp(n);
// rs = 00000000 00000000 10000000 00011010
// rs << RESIZE_STAMP_SHIFT) + 2 =
// 10000000 00011010 00000000 00000010
// 将扩容戳左移16位，符号位是1，代表这个数为负数
// 低16位在表示当前扩容的线程是多少个， +2表示为有一个线程正在扩容，10-9表示位9个线程正在扩容
// 为什么低位值为2时，代表有一个线程正在扩容：
// 每一个线程线程扩容完毕后，会对低16位进行-1的操作，当最后一个线程扩容完毕后，减1操作的结果还是-1
// 当值为-1时，要对老数组进行一波扫描，查看是否有遗漏的数据没有迁移到新数组
if (U.compareAndSetInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
// 第一个扩容的线程
transfer(tab, null);
}
}
}
6.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;
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;
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
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) {
TreeNode<K,V> x, f = first;
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;
}
// 加锁方法
private final void lockRoot() {
if (!U.compareAndSetInt(this, LOCKSTATE, 0, WRITER))
contendedLock(); // offload to separate method
}
// 解锁方法
private final void unlockRoot() {
lockState = 0;
}
static final int WRITER = 1;
static final int WAITER = 2;
static final int READER = 4;
private final void contendedLock() {
boolean waiting = false;
for (int s;;) {
// 判断当前是否有线程持有锁
if (((s = lockState) & ~WAITER) == 0) {
// 没有则通过CAS加上写锁
if (U.compareAndSetInt(this, LOCKSTATE, s, WRITER)) {
if (waiting)
waiter = null;
return;
}
}
// 判断当前是否有线程在等待
else if ((s & WAITER) == 0) {
// 如果没有，则将LOCKSTATE｜WAITER，并且将waiting 设置为true，waiter设置为当前线程
if (U.compareAndSetInt(this, LOCKSTATE, s, s | WAITER)) {
waiting = true;
waiter = Thread.currentThread();
}
}
// 解锁
else if (waiting)
LockSupport.park(this);
}
}
7.resizeStamp
// 计算扩容表示戳
static final int resizeStamp(int n) {
// 32 = 00000000 00000000 00000000 00100000
// Integer.numberOfLeadingZeros(n) = 26
// 00000000 00000000 10000000 00000000
// ｜
// 00000000 00000000 00000000 00011010
// 00000000 00000000 10000000 00011010
// 作用：用来确保我之后的标识肯定为负数，并且还能记录当前数组是从什么长度开始扩容
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
8.transfer
// 开始扩容，eg:以32扩容到64
// 第一个扩容，nextTab = null，tab是老数组
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
// n:代表原数组长度
// stride:代表一个线程一次迁移多少数据到新数组。
int n = tab.length, stride;
// 基于CPU的内核数量来计算，每个线程一次性迁移多少长度的数据最合理
// eg：数组长度为 32 >>> 3 = 4
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
// 根据CPU计算每个线程一次迁移多长的数据到新数组，
// 如果结果大于16，使用计算结果，如果结果小于16，使用最小长度16
stride = MIN_TRANSFER_STRIDE;
// 第一个进来扩容的线程需要把新数组创建出来
if (nextTab == null) {
try {
// 将原数组长度左移以为，变成新数组长度，相当于新数组的长度是原来的2倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 将新数组给nextTab
nextTab = nt;
} catch (Throwable ex) {
// 说明已经达到数组长度的最大取值范围
sizeCtl = Integer.MAX_VALUE;
// 设置sizeCtl后直接退出
return;
}
// 将成员变量的新数组赋值
nextTable = nextTab;
// 迁移数据时用到的标识，默认值为原数组长度
transferIndex = n; // 32
}
// 新数组长度
int nextn = nextTab.length; // 64
// 构建一个新的node 并将新数组传进去，并且新node的hash值为-1
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 代表当前线程需要接受任务，然后执行迁移，如果为false，代表已经接受完任务
boolean advance = true;
// 是否迁移结束
boolean finishing = false;
// 开始迁移数据，定义变量 i = 0,bound = 0
for (int i = 0, bound = 0;;) {
// f = null
// fh = 0
Node<K,V> f; int fh;
// 当前线程要接收任务
while (advance) {
// nextIndex = 32
// nextBound = 16
int nextIndex, nextBound;
// 第一次进来 --i = -1 ;bound = 0，并且判断当前任务是否处理完成
// 该处是用来判断该线程是否领取完所有任务的
if (--i >= bound || finishing)
advance = false;
// 第一次进来时 transferIndex 为原数组表示，并赋值给nextIndex
// 在任务都领取完后，transferIndex肯定是小于等于0的，代表没有迁移数据可以领取
else if ((nextIndex = transferIndex) <= 0) {
// 代表没有任务可以领取，结束了
i = -1;
advance = false;
}
// 当前线程开始领取任务
// stride = 16 默认值
// 通过CAS将 TRANSFERINDEX 的值从32 改为16
else if (U.compareAndSetInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
// 对bound进行复制
bound = nextBound;
// 对i赋值 因为数组下标从0开始，所以32的长度，数组最大为31
i = nextIndex - 1;
// 代表当前线程领取到任务
advance = false;
}
}
// 判断扩容是否已经结束
// i < 0 :当前线程没有接收到任务
// i >= n: 迁移索引位置，不可能大于数组长度，不会成立
// i + n >= nextn: 因为i最大值就是数组索引最大值，不会成立
if (i < 0 || i >= n || i + n >= nextn) {
// 当前线程没有接收到任务
int sc;
// finishing 为true，代表扩容结束
if (finishing) {
// 将nextTable 设置为null
nextTable = null;
// 将当前数组的引用指向新数组
table = nextTab;
// 重新计算扩容阈值
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 当前线程没有接收到任务，让当前线程结束扩容操作
// 采用CAS的方式，将sizeCtl -1 ，代表当前并发扩容的线程数 - 1
if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// sizeCtl的高16位是基于数组长度计算的扩容戳，低16位是当前正在扩容的线程数
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
// 代表当前线程并不是最后一个退出扩容的线程，直接结束
return;
// 如果是最后一个退出，将finishing、advance 设置为true
finishing = advance = true;
// 将i设置为老数组长度，让最后一个线程从尾到头，再次检查一下，是否所有的数据迁移完成
i = n; // recheck before commit
}
}
// 获取指定i位置的node对象斌判断是否为null
// 并将数组位置的数据赋值给f
else if ((f = tabAt(tab, i)) == null)
// 当前桶位置的没有数据，无需迁移，直接将当前桶位置设置为fwd，标识为迁移完成
advance = casTabAt(tab, i, null, fwd);
// 拿到当前i位置的hash值，如果为MOVED，证明数据已经迁移过了
else if ((fh = f.hash) == MOVED)
// 一般是给最后扫描时，使用的判断，如果迁移完毕，直接跳过当前位置
advance = true;
else {
// 当前桶位置有数据，先锁住当前桶位置
synchronized (f) {
// 判断之前取出来的数据，是否为当前数据
if (tabAt(tab, i) == f) {
// lastRun机制
// ln = null -- lowNode
// hn = null -- HighNode
Node<K,V> ln, hn;
// hash值大于0，当前node属于正常情况 为链表结构
if (fh >= 0) {
// 只有两种结果，一个是数组大小，一个是0
// fh为f节点的hash值，n为原数组大小
int runBit = fh & n;
// 将f赋值给lastRun
Node<K,V> lastRun = f;
// 循环的目的，就是为了得到的链表下hash & n结算，结果一致的最后一些数据
// 在迁移数据时，只需要迁移到lastrun
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
// runBit == 0 赋值给ln
if (runBit == 0) {
ln = lastRun;
hn = null;
}
// runBit == n 赋值给hn
else {
hn = lastRun;
ln = null;
}
// 循环到lastrun指向的数据即可，后续不需要再遍历
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);
}
// 采用CAS将ln放到原位置上
setTabAt(nextTab, i, ln);
// 采用CAS放到原位置+老数组长度
setTabAt(nextTab, i + n, hn);
// 采用CAS的方式，将当前桶位置设置为fwd，标识为迁移结束
setTabAt(tab, i, fwd);
// 保证可以进入while循环
advance = true;
}
// 红黑树操作
else if (f instanceof TreeBin) {
// 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;
}
}
// 判断是否需要专为链表
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;
}
}
}
}
}
}
三、获取数据
public V get(Object key) {
// 定义一堆变量
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 计算hash值
int h = spread(key.hashCode());
// 判断数组的是否为空，并判断所在位置是否为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(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下的find方法查找
else if (eh < 0)
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;
}
ForwardingNode下的find
// 标识改次查询的数据，已经呗迁移到新数组中，直接去循环新数组查询数据
Node<K,V> find(int h, Object k) {
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
// 判断新数组中key是否存在，若不存在则，直接返回
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (;;) {
int eh; K ek;
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
// 发现新数组又在扩容，则退出内层循环，直接返回外层循环，再次便利新的数组
if (eh < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
return e.find(h, k);
}
if ((e = e.next) == null)
return null;
}
}
}
Treebin下的find方法
final Node<K,V> find(int h, Object k) {
if (k != null) {
// 循环双
for (Node<K,V> e = first; e != null; ) {
int s; K ek;
// 判断当前是否有写锁 lockState TreeBin的锁状态
if (((s = lockState) & (WAITER|WRITER)) != 0) {
// 如果进来了，说明当前存在读锁或者写锁，则直接从双向链表中获取数据
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
e = e.next;
}
// 说明当前没有等待写锁或持有写锁的，则通过CAS 对 lockState + 4 锁住当前数据
else if (U.compareAndSetInt(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 -4 的锁，然后判断 是否等于waiter 说明有线程在等待，==null 说明当前线程是最后一个在红黑树中检索的线程，还有其他线程在等待持有写锁，此时需要唤醒等待的写锁
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}
总结
以上就是CouncurrentHashMap的源码解析，如果有描述错误的地方，希望大家支持，一起讨论。🙏🙏🙏
扫一扫
941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
