Java集合系列---ConcurrentHashMap源码解析
ConcurrentHashMap是Java并发容器的一员，jdk1.8以后的基本的数据结构和HashMap相似，也是选用了数组+链表/红黑树的结构，在jdk1,.7以前则是采用了分段锁的技术。ConcurrentHashMap所有操作都是线程安全的，但获取操作不必锁定，并且不支持以某种防止所有访问的方式锁定整个表。
它主要是在桶的入口节点加上Segent节点，用于判断该节点是否能进入
1 继承关系
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
可以看出它实现了ConcurrentMap接口
2 基本属性
private static final int MAXIMUM_CAPACITY = 1 << 30;//表的最大容量
private static final int DEFAULT_CAPACITY = 16;//默认表的大小
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//最大数组大小
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;//决定Segment数组的大小并发级别
private static final float LOAD_FACTOR = 0.75f;//默认加载因子
static final int TREEIFY_THRESHOLD = 8;//这个值是从链表变成红黑树的阀门，如果大于这个值就会转变
static final int UNTREEIFY_THRESHOLD = 6;// 红黑树节点小于6的时候转链表
static final int MIN_TREEIFY_CAPACITY = 64;//转换为红黑树之前还得判断数组的容量是否大于64
private static final int MIN_TRANSFER_STRIDE = 16;//每次进行转移的最小值
private static int RESIZE_STAMP_BITS = 16;// 生成sizeCtl所使用的bit位数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;//进行扩容所允许的最大线程数量
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS; // 记录sizeCtl中的大小所需要进行的偏移位数
static final int MOVED = -1; // hash for forwarding nodes 表示该节点正在处于扩容工作，内部有个指针指向nextTable
static final int TREEBIN = -2; // hash for roots of trees 红黑树的首节点，内部不存key、value，只是用来表示红黑树
static final int RESERVED = -3; // hash for transient reservations 当hash桶为空时，充当首结点占位符，用来加锁
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash 普通节点的hash计算
static final int NCPU = Runtime.getRuntime().availableProcessors();//CPU数量
transient volatile Node<K,V>[] table;// 表
private transient volatile Node<K,V>[] nextTable;// 下一个表
private transient volatile long baseCount; // 基本计数
private transient volatile int sizeCtl;// 对表初始化和扩容控制
private transient volatile int transferIndex;// 扩容下另一个表的索引
private transient volatile int cellsBusy; // 旋转锁
private transient volatile CounterCell[] counterCells;// counterCell表
//视图
private transient KeySetView<K,V> keySet;
private transient ValuesView<K,V> values;
private transient EntrySetView<K,V> entrySet;
３ 构造函数
//1. ConcurrentHashMap()型构造函数
public ConcurrentHashMap() {}
//说明：该构造函数用于创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
//2. ConcurrentHashMap(int)型构造函数
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0) // 初始容量小于0，抛出异常
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY ://找到最接近该容量的幂的二次方
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
// 初始化
this.sizeCtl = cap;
}
//说明：该构造函数用于创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
//3. ConcurrentHashMap(Map)型构造函数
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
// 将集合m的元素全部放入
putAll(m);
}
//说明：该构造函数用于构造一个与给定映射具有相同映射关系的新映射。
//4. ConcurrentHashMap(int, float)型构造函数
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
//说明：该构造函数用于创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (1) 的新的空映射。
//5. ConcurrentHashMap(int, float, int)型构造函数
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) // 合法性判断
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
对于构造函数而言，会根据输入的initialCapacity的大小来确定一个最小的且大于等于initialCapacity大小的2的n次幂,如initialCapacity为15，则sizeCtl为16，若initialCapacity为16，则sizeCtl为16。若initialCapacity大小超过了允许的最大值，则sizeCtl为最大值。
concurrencyLevel只是用来确定sizeCtl的大小，在JDK1.8中的并发控制都是针对具体的桶而言，即有多少个桶就可以允许多少个并发数
4关键的类
Node节点构成每个元素的基本类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//key的hash值
final K key;//key
volatile V val;//value
volatile Node<K,V> next;//表示链表中的下一个节点
}
树节点
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
(1)parent:表示节点的父节点
(2)left:表示左节点
(3)right:表示右节点
(4)prev:表示前驱节点
(5)red：表示是红树还是黑树
TreeBin 用作树的头结点，只存储root和first节点，不存储节点的key、value值。
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root;
volatile TreeNode<K,V> first;
volatile Thread waiter;
volatile int lockState;
// values for lockState
static final int WRITER = 1; // set while holding write lock
static final int WAITER = 2; // set when waiting for write lock
static final int READER = 4; // increment value for setting read lock
}
ForwardingNode在转移的时候放在头部的节点，是一个空节点
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
}
Segment继承了ReentrantLock锁
static class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
final float loadFactor;
Segment(float lf) { this.loadFactor = lf; }
}
5 核心方法
1）put
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
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();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//用来返回节点数组的指定位置的节点的原子操作
if (casTabAt(tab, i, null,//cas原子操作，在指定位置设定值也就是该桶为空在该桶存入第一个值
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)//当前Map在扩容，先协助扩容，在更新值。
tab = helpTransfer(tab, f);// 假如桶的头节点为ForwardingNode（转移时的头结点）
else {
V oldVal = null;
synchronized (f) {// 普通的节点，将头锁住方便更新
if (tabAt(tab, i) == f) {// 再次检测下，如果不等说明被其他线程更新，等待一次重新操作
if (fh >= 0) {// 如果是正常节点，直接往后查询
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {//遍历链表
K ek;
if (e.hash == hash &&//hash值和key值相同的话直接覆盖
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)// 如果已经找到，则根据onlyIfAbsent是否更新
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {//如果不是同样的hash，同样的key的时候，则判断该节点的下一个节点是否为空，为空的话把这个要加入的节点设置为当前节点的下一个节点
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) { //调用putTreeVal方法，将该元素添加到树中去
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {binCount设置为2，防止转化成二叉树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 元素个数增加1，binCount表示当前插入数据所在桶元素序号（1，2...），根据条件决定是否扩容
addCount(1L, binCount);
return null;
}
2）table扩容
新增节点之后，addCount统计tab中的节点个数大于阈值（sizeCtl），会触发transfer，重新调整节点位置。
//x为1，check默认是0，只有hash冲突了传过来的值才会大于1，
//且它的大小是链表的长度（不为红黑树的话）
private final void addCount(long x, int check) {
//CounterCell[]也是一个继承了锁的对象，指向countcell
CounterCell[] as; long b, s;
//如果计数盒子不是空或者cas修改baseCount失败
// 完成了对baseCount的更新，s = b+x；x = 1;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
/**
如果计数盒子是空（尚未出现并发）
如果随机取余一个数组位置为空
或者修改这个位置的变量失败（出现并发）
执行fullAddCount方法，并结束
**/
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); // 多线程修改baseCount时，竞争失败的线程
//会执行fullAddCount(x, uncontended),把x的值插入到counterCell类中
return;
}
if (check <= 1)
return;
s = sumCount();
}
//check大于0说明需要检查是否需要扩容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
/*如果map.size（）大于sizeCtl（达到扩容阈值需要扩容）且
table不是空，且table的长度小于1 << 30.(可以扩容)
*/
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);//根据length得到一个标识
if (sc < 0) {
/*
如果sc的低16位不等于标识符（校验异常 sizeCtl变化了）
如果 sc == 标识符 + 1 （扩容结束了，不再有线程进行扩容）
（默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就
会将 sc 减一。这个时候，sc 就等于 rs + 1）
如果 sc == 标识符 + 65535（帮助线程数已经达到最大）
如果 nextTable == null（结束扩容了）
如果 transferIndex <= 0 (转移状态变化了)
结束循环
*/
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0) // 其他线程在初始化，break；
break;
// 如果可以帮助扩容，那么将 sc 加 1. 表示多了一个线程在帮助扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
/*
如果不再扩容，将sc更新；标识符左移16位，然后+2,也就是变成一个负数。高16
位是标识符，低16位初始是2
*/
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
//更新sizeCtl为负数后，开始扩容
transfer(tab, null);
s = sumCount();
}
}
}