前言
JDK 1.8 版本开始，提供了一种线程安全的 Map，即 ConcurrentHashMap。底层使用 synchronized + CAS 的方式，保证线程安全的同时，也具备了一定的并发性能。
常见问题
1、ConcurrentHashMap的存储结构？
由数组+链表+红黑树组成。链表中查找一个元素的时间复杂度是 0(n)，而红黑树是 0(logn)
2、ConcurrentHashMap如何处理哈希冲突的？
使用链地址法。
3、为什么扩容因子设置为0.75，链表长度阈值为8？
遵循泊松分布(Poisson Distribution)，这样可以让链表转红黑树的几率变得很小，链表转红黑树会有性能损耗。
4、Node数组的扩容时机（满足如下任意一个条件即可）
如果Node数组长度<64，并且链表长度>=8时，对Node数组扩容为原来长度的两倍。
当ConcurrentHashMap内部的元素个数达到了0.75n（n为Node数组的长度），对Node数组扩容为原来长度的两倍。
5、链表与红黑树的相互转化
如果Node数组长度>=64，并且链表长度>=8时，则将链表转化成红黑树。
如果红黑树内部的元素个数<=6，则将红黑树转化成链表。
put、putAll 方法
put 方法
public V put(K key, V value) {
return putVal(key, value, false);
}
putAll 方法
public void putAll(Map<? extends K, ? extends V> m) {
tryPresize(m.size());
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putVal(e.getKey(), e.getValue(), false);
}
可见，put 方法、putAll 方法都会调用 putVal 方法。
putVal 方法
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 校验key、value非空
if (key == null || value == null) throw new NullPointerException();
// 计算key的哈希值（spread方法 => (h ^ (h >>> 16)) & 0x7fffffff）
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果Node数组还没有初始化
if (tab == null || (n = tab.length) == 0)
// 初始化Node数组
tab = initTable();
// 根据key的哈希值计算数组下标，如果该数组下标的位置还没有元素
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 构建Node节点，落到Node数组对应下标处
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
// 结束循环
break;
}
// 如果Node节点的哈希值等于-1，即当前线程完成了所负责的扩容工作
else if ((fh = f.hash) == MOVED)
// 进行辅助扩容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 对指定下标位置的Node节点加锁
synchronized (f) {
// 如果对应数组下标处的节点仍然是上述的Node节点
if (tabAt(tab, i) == f) {
// 针对链表的处理
if (fh >= 0) {
// 使用binCount记录链表的长度
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果key的哈希值相同且key也相同
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
// 如果onlyIfAbsent参数为false，则使用新值覆盖旧值；反之，不会覆盖旧值
if (!onlyIfAbsent)
e.val = value;
// 结束循环
break;
}
Node<K,V> pred = e;
// 构建新的Node节点
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;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 如果链表长度大于等于8
if (binCount >= TREEIFY_THRESHOLD)
// 扩容或者转化为红黑树
treeifyBin(tab, i);
// 如果存在旧值，则直接返回旧值
if (oldVal != null)
return oldVal;
// 结束循环
break;
}
}
}
// 主要用于统计元素总个数然后判断是否满足扩容的条件，如果满足进行扩容
addCount(1L, binCount);
return null;
}
initTable 方法
用于初始化Node数组
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 如果Node数组还未初始化，则一直进行循环
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield();
// 使用CAS方式将sizectl属性的值更新为-1，表示Node数组在初始化中
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 如果Node数组还未初始化
if ((tab = table) == null || tab.length == 0) {
// 获取Node数组的初始容量，默认16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 初始化Node数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// 计算扩容阈值，即0.75*n，默认12
sc = n - (n >>> 2);
}
} finally {
// 最终将扩容阈值赋值给sizeCtl属性
sizeCtl = sc;
}
// 结束while循环
break;
}
}
// 返回初始化完成的Node数组
return tab;
}
sizeCtl ：大于等于0（未初始化）=> -1（初始化中）=> 0.75n（初始化完成）
treeifyBin 方法
如果Node数组长度大于等于64并且链表长度大于等于8时，链表转换为红黑树
如果Node数组长度小于64并且链表长度大于等于8时，对Node数组扩容为原来的两倍，并进行数据迁移
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
// 如果Node数组长度小于64，则触发扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 对Node数组进行多线程并发扩容，扩容到原长度*2（包括旧数据的迁移）
tryPresize(n << 1);
// 如果Node数组长度大于等于64，则将链表转化成红黑树
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);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
tryPresize 方法
扩容Node数组并进行数据迁移
private final void tryPresize(int size) {
// 计算扩容后的容量
// MAXIMUM_CAPACITY：1 << 30
// tableSizeFor(...)：找到大于等于目标值的且最小的2的n次幂
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
// 如果Node数组处于未扩容的状态，就一直进行循环
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
// 如果Node数组未初始化
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数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 使用新的Node数组替换旧的Node数组
table = nt;
// 计算新的扩容阈值
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
// 如果已经扩容完成或者达到最大容量，则无需进行后续操作直接跳出循环
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
// 处理数据迁移
else if (tab == table) {
// 计算扩容戳
int rs = resizeStamp(n);
// 如果Node数组在扩容中
if (sc < 0) {
Node<K,V>[] nt;
// 判断当前扩容工作是否没有结束，并且当前线程是否有机会参与到扩容工作
// 条件一、判断当前线程获取到的扩容戳是否是本次扩容生成的扩容戳（true-不是；false-是）
// 条件二、判断当前线程是否需要参与到扩容工作（true-不需要；false-需要）
// 条件三、判断当前参与扩容工作的线程数是否达到了最大值（true-是；false-否）
// 条件四、通过判断nextTable是否为空，进而判断扩容过程是否已经结束（true-已经结束；false-还未结束）
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
// 跳出循环
break;
// 如果当前线程成功参与到扩容工作（每增加一个参与扩容的线程，则对sizectl属性在低位加1）
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
// 扩容与数据迁移
transfer(tab, nt);
}
// 此时Node数组还未扩容，但是Node数组的长度达到了扩容阈值
// 对sizectl属性值左移16位，此时高16位表示扩容戳，低16位表示参与扩容的线程的数量
// 注意、每增加一个参与扩容的线程，则对sizectl属性在低位加1。并且只有第一次需要加2
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 扩容与数据迁移
transfer(tab, null);
}
}
}
transfer 方法
Node数组扩容与数据迁移（链表：扩容为原来的两倍；对需要迁移的节点放到高位链表、不需要迁移的节点放到低位链表，最后这两个链表加入到扩容后的Node数组的指定下标处）
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
// n：扩容前的Node数组的长度
int n = tab.length, stride;
// stride：每个线程负责的扩容范围，通常是16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
// 如果扩容后的Node数组还没有初始化
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
// 初始化扩容后的Node数组，长度扩容为原来的2倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 第一次记录扩容前的Node数组的长度
transferIndex = n;
}
// 记录扩容后的Node数组的长度
int nextn = nextTab.length;
// 用于标记数据迁移完成的节点
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
// 标记数据迁移是否完成
boolean finishing = false;
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
// 将transferIndex属性赋值到nextIndex
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 比如扩容前Node数组的长度为32，则第一次循环得到的范围为[16, 31]，然后第二次的范围为[0, 15]，使用nextBound、i分别记录左起点、右起点
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);
return;
}
// 对参与扩容的线程数减一
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n;
}
}
// 如果指定下标的Node节点为空（也就是不需要数据迁移），使用CAS方式更新为ForwardingNode节点，即数据迁移完成
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 如果节点的哈希值为-1，则表示该节点为ForwardingNode节点，即数据迁移完成
else if ((fh = f.hash) == MOVED)
// 标记可以进行下一次的区间遍历
advance = true;
else {
// 对当前需要进行数据迁移的Node节点加锁
synchronized (f) {
// 校验Node数组下标为i的节点是否发生变化
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// 如果是链表
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
// 从当前Node节点的后继节点开始，沿着链表向后遍历
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
// 更新runBit
runBit = b;
// 更新lastRun
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
// 从当前Node节点开始，沿着链表向后遍历
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);
}
// 将低位链表加入到扩容后的Node数组的指定下标处
setTabAt(nextTab, i, ln);
// 将高位链表加入到扩容后的Node数组的指定下标处
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;
}
}
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;
}
}
}
}
}
}
addCount 方法
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 如果CounterCell数组已经初始化，或者CAS操作更新元素个数失败（说明存在多个线程竞争）
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
// 条件一与二、判断CounterCell数组是否未初始化
// 条件三、判断CounterCell数组指定下标元素是否为空
// 条件四、判断CAS操作是否更新CounterCell的value失败
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
// 初始化CounterCell数组，可能会对CounterCell数组进行扩容
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
// 计算当前的元素个数
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// sizeCtl 如果为负数，表示正在扩容中；如果为正数，表示一个扩容阈值
// 条件1、Node数组在扩容中或者满足了Node数组扩容的条件
// 条件2、Node数组非空
// 条件3、Node数组的元素个数 < (1 << 30)
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 计算扩容戳
int rs = resizeStamp(n);
// 如果Node数组在扩容中
if (sc < 0) {
// 判断当前扩容工作是否没有结束，并且当前线程是否有机会参与到扩容工作
// 条件一、判断当前线程获取到的扩容戳是否是本次扩容生成的扩容戳（true-不是；false-是）
// 条件二、判断当前线程是否需要参与到扩容工作（true-不需要；false-需要）
// 条件三、判断当前参与扩容工作的线程数是否达到了最大值（true-是；false-否）
// 条件四、通过判断nextTable是否为空，进而判断扩容过程是否已经结束（true-已经结束；false-还未结束）
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 如果当前线程成功参与到扩容工作（每增加一个参与扩容的线程，则对sizectl属性在低位加1）
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
// 扩容与数据迁移
transfer(tab, nt);
}
// 此时Node数组还未扩容，但是Node数组的长度达到了扩容阈值
// 对sizectl属性值左移16位，此时高16位表示扩容戳，低16位表示参与扩容的线程的数量
// 注意、每增加一个参与扩容的线程，则对sizectl属性在低位加1。并且只有第一次需要加2
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 扩容与数据迁移
transfer(tab, null);
// 计算当前的元素个数
s = sumCount();
}
}
}
fullAndCount 方法
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit();
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false;
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
// 如果CounterCell数组已经初始化
if ((as = counterCells) != null && (n = as.length) > 0) {
// 如果CounterCell数组指定下标的元素为空
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) {
// 初始化CounterCell
CounterCell r = new CounterCell(x);
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try {
CounterCell[] rs; int m, j;
// 再次判断如果CounterCell数组已经初始化，并且CounterCell数组指定下标的元素为空
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
// 将上述的CounterCell添加到CounterCell数组指定下标处
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
// 如果上述操作成功，则结束循环
if (created)
break;
// 如果上述操作失败，则重试
continue;
}
}
collide = false;
}
else if (!wasUncontended)
wasUncontended = true;
// 如果使用CAS方式对CounterCell更新value值成功，则结束循环
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
else if (counterCells != as || n >= NCPU)
collide = false;
else if (!collide)
collide = true;
// 对CounterCell数组进行扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {
// 对CounterCell数组扩容为原来的2倍
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;
}
h = ThreadLocalRandom.advanceProbe(h);
}
// 对CounterCell数组进行初始化
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try {
if (counterCells == as) {
// 初始化CounterCell数组
CounterCell[] rs = new CounterCell[2];
// 初始化指定下标处的CounterCell元素
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
// 如果上述操作成功，则结束循环
if (init)
break;
}
// 如果使用CAS方式对基础值更新成功，则结束循环
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break;
}
}
sumCount 方法
对CounterCell数组的每个元素进行累加求和。结合上下文，就是获取元素个数。
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;
}
helpTransfer 方法
如果当前线程负责的扩容工作已经完成，则帮助其它线程完成扩容工作。
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 如果Node数组非空，并且当前节点是ForwardingNode类型的节点，即所负责的扩容工作已经完成
// 并且nextTab非空，即表示扩容工作还未完成
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) {
// 判断当前扩容工作是否没有结束，并且当前线程是否有机会参与到扩容工作
// 条件一、判断当前线程获取到的扩容戳是否是本次扩容生成的扩容戳（true-不是；false-是）
// 条件二、判断当前线程是否需要参与到扩容工作（true-不需要；false-需要）
// 条件三、判断当前参与扩容工作的线程数是否达到了最大值（true-是；false-否）
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
// 结束循环
break;
// 如果当前线程成功参与到扩容工作（每增加一个参与扩容的线程，则对sizectl属性在低位加1）
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 扩容与数据迁移
transfer(tab, nextTab);
// 结束循环
break;
}
}
return nextTab;
}
return table;
}
size 方法
public int size() {
// 使用sumCount方法计算元素个数
long n = sumCount();
// 元素个数最大值为Integer类型的最大值，即2147483647
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}