在Java并发编程中，ConcurrentHashMap是使用频率最高的并发容器之一。相比传统的Hashtable和Collections.synchronizedMap()，它通过更细粒度的锁机制实现了更高的并发性能。本文将通过JDK8源码解析，深入剖析其实现原理。
Java 7及之前的分段锁机制
采用Segment数组（继承ReentrantLock）实现分段锁，每个段（Segment）独立加锁，不同段的修改可以并发进行。
而到了Java 8之后，ConcurrentHashMap抛弃了分段锁，转而采用Node数组+链表+红黑树的结构，每个Node节点作为锁的最小粒度。 当插入或者更新时，如果该Node还未初始化，会使用CAS操作来保证原子性；否则会用synchronized锁定当前Node，这样其他线程要操作同一个Node时会被阻塞，但不同Node的写入可以并发进行。
ConcurrentHashMap的内部机制（JDK1.8）
接下来我们通过源码来分析一下ConcurrentHashMap
初始化
public ConcurrentHashMap(int initialCapacity) {
// 判断初始化参数
if (initialCapacity < 0)
throw new IllegalArgumentException();
// 用传进来的参数值与 MAXIMUM_CAPACITY >>> 1 进行对比，若大于则使用MAXIMUM_CAPACITY
// 小于则使用距离initialCapacity最近的2次幂
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
// initialCapacity 为 10，那么得到 sizeCtl 为 16，如果 initialCapacity 为 17，得到 sizeCtl 为 32。
private static final int tableSizeFor(int c) {
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;
}
ConcurrentHashMap延迟初始化的时候根据传入的初始容量（或使用默认容量）计算出一个“扩容阈值”并把它存入 sizeCtl 字段,此时并未分配内存，只有第一次 put 才初始化内部数组分配内存。
put 过程
public V put(K key, V value) {
return putVal(key, value, false);
}
/**
* Implementation for put and putIfAbsent
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 传入的key\value都不能为空
if (key == null || value == null) throw new NullPointerException();
// 计算下标
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)
tab = initTable();
// 如果当前数组该下标没有数据,直接通过CAS插入数据
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K, V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 判断当前位置数据是否正在扩容
else if ((fh = f.hash) == MOVED)
// 如果在扩容,则当前线程帮助其扩容
tab = helpTransfer(tab, f);
else {
// f 是该位置的头节点，而且不为空
V oldVal = null;
// 获取数组该位置的头节点的监视器锁
synchronized (f) {
if (tabAt(tab, i) == f) {
// static final int MOVED = -1; // 代表当前hash位置的数据正在扩容
// static final int TREEBIN = -2; // 代表当前hash位置下挂载的是一个红黑树
// static final int RESERVED = -3; // 预留当前索引位置
// 判断下当前的fh是否大于0
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;
// onlyIfAbsent为false，代表key一致时，直接覆盖数据，onlyIfAbsent为true，代表key一致时，什么都不做，key不存在，正常添加
if (!onlyIfAbsent)
e.val = value;
break;
}
// key不相同，判断是否是在链表尾
Node<K, V> pred = 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;
// 将当前数据放入到红黑树中
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;
}
put的整个流程包含：空值校验、哈希计算、表初始化、CAS无锁插入、协助扩容、链表/红黑树插入判断，最后触发计数更新和可能的树化/扩容操作。接下来看一下关键节点的源码。
初始化数组
// sizeCtl：是数组在初始化和扩容操作时的一个控制变量
// =-1：代表当前数组正在初始化
// <-1：低16位代表当前数组正在扩容的线程个数（如果1个线程扩容，值为-2，如果2个线程扩容，值为-3）
// =0：代表数组还没初始化
// >0：代表当前数组的扩容阈值，或者是当前数组的初始化大小
private final Node<K, V>[] initTable() {
Node<K, V>[] tab;
int sc;
// 当前的初始化没有完成时,会一直进行该while循环
while ((tab = table) == null || tab.length == 0) {
// 如果小于0,代表当前数组正在扩容或者初始化， 让当前线程等待一下
if ((sc = sizeCtl) < 0)
Thread.yield();
// 尝试将SIZECTL从SC更改为-1
// 通过CAS机制，保证只有一个线程执行数组初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 再次进行检查判断，防止刚好初始化完
if ((tab = table) == null || tab.length == 0) {
// 不传入入参,走DEFAULT_CAPACITY的扩容
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
// 将扩容阈值赋予sizeCtl
sizeCtl = sc;
}
break;
}
}
return tab;
}
这个过程比较简单，就是初始化一个合适大小的数组，然后会设置 sizeCtl。
链表转红黑树
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)
// 扩容长度是当前数组长度的2倍
tryPresize(n << 1);
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));
}
}
}
}
}
扩容
private final void tryPresize(int size) {
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;
// 如果数组没有初始化，进行初始化
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
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 = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
} else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
// 判断引用是否一致
else if (tab == table) {
int rs = resizeStamp(n);
// 这里sc不存在<0的情况
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);
} else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
