常量
// 散列表数组(即table)长度最大限制
private static final int MAXIMUM_CAPACITY = 1 << 30;
// table默认长度
private static final int DEFAULT_CAPACITY = 16;
// 最大可能的数组长度，toArray方法使用(官方直译)，常用方法中未涉及
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 并发级别, 之前的版本留下来的, 无用
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 负载因子
private static final float LOAD_FACTOR = 0.75f;
// 链表转红黑树的阈值，9个节点开始转
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 链表转红黑树是数组最小长度, 当最小长度达到64, 并且链表长度达到8, 才开始转红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
// 并发扩容时最小步长
private static final int MIN_TRANSFER_STRIDE = 16;
// 扩容相关, 计算扩容时生成的一个标识戳, 全局不变
private static int RESIZE_STAMP_BITS = 16;
// 并发扩容的最大线程数, 最大为65535
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 扩容相关, 为16
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
/** 节点哈希字段的编码 */
// node节点的hash为-1时, 表示当前节点是FWD节点, 已经迁移完成
static final int MOVED = -1;
// node节点的hash为-2, 表示当前节点是TreeBin节点
static final int TREEBIN = -2;
// node节点的hash为-3, 表示当前节点为ReservationNode
static final int RESERVED = -3; /
成员变量
// table数组
transient volatile Node<K,V>[] table;
// 扩容过程中的新table, 扩容结束后会将nextTable设置为null
private transient volatile Node<K,V>[] nextTable;
// LongAdder中的baseCount, 未发生竞争时 或者 当前LongAdder处于加锁状态时, 增量累积到baseCount中
private transient volatile long baseCount;
/**
* sizeCtl < 0
* 1. -1表示当前table正在初始化(有线程正在创建table数组), 当前线程需要自旋等待
* 2. 表示当前table数组正在进行扩容, 高16位表示扩容的标识戳, 低16位表示: (1 + nThread) 当前参与并发扩容的线程数量(这个状态最重要)
*
* sizeCtl = 0
* 表示创建table数组时, 使用DEFAULT_CAPACITY为大小
*
* sizeCtl > 0
* 1. 如果table为初始化, 表示初始化大小
* 2. 如果table已经初始化, 表示下次扩容时的阈值(n * 0.75)
*/
private transient volatile int sizeCtl;
// 扩容过程中, 记录当前进度, 所有线程都需要从transferIndex中分配区间任务, 去执行自己相应的区间
private transient volatile int transferIndex;
/**
* LongAdder中的cellBusy
* 0 表示当前LongAdder对象无锁状态
* 1 表示当前LongAdder对象加锁状态, 只有一个对象能持有加锁状态
*/
private transient volatile int cellsBusy;
/**
* LongAdder中的cells数组, 当baseCount发生竞争后, 会创建cells数组
* 线程会通过计算hash值, 取到自己的cell, 将增量累加到指定cell中
* 总数 = sum(cells) + baseCount
*/
private transient volatile CounterCell[] counterCells;
内部类
链表节点Node
static class Node<K,V> implements Map.Entry<K,V> {
// 节点hash值，经过扰动运算得出来的
final int hash;
final K key;
volatile V val;
// 后继节点
volatile Node<K,V> next;
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
}
红黑树节点TreeNode
static final class TreeNode<K,V> extends Node<K,V> {
// 父节点
TreeNode<K,V> parent;
// 左子节点
TreeNode<K,V> left;
// 右子节点
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next,
TreeNode<K,V> parent) {
super(hash, key, val, next);
this.parent = parent;
}
}
红黑树链表节点TreeBin
static final class TreeBin<K,V> extends Node<K,V> {
// 红黑树根节点
TreeNode<K,V> root;
// 链表的头节点
volatile TreeNode<K,V> first;
// 等待者线程(当前lockState是读锁状态)
volatile Thread waiter;
/**
* 1. 写锁状态 写是独占状态, 以table来看, 真正进入到TreeBin中的写线程, 同一时间只有一个
* 2. 读锁状态 读锁是共享的, 同一时刻可以有多个线程, 同时进入到TreeBin对象中获取数据, 每一个线程都会给lockState + 1
* 3. 等待者状态(写线程在等待), 当TreeBin中有读线程目前正在读取数据时, 写线程无法修改数据, 那么就将lockState的最低两位设置为0b,10
*/
volatile int lockState;
// 锁状态的；值
static final int WRITER = 1;
static final int WAITER = 2;
static final int READER = 4;
}
扩容完成的红黑树节点ForwardingNode
static final class ForwardingNode<K,V> extends Node<K,V> {
// 扩容中临时table数组
final Node<K,V>[] nextTable;
// ForwardingNode是node的子类, hash值为moved(-1), nextTable指向了扩容是临时存储node的新table
// 写线程: 需要参与并发扩容 读线程: 调用find方法到新表继续查询
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
}
部分方法
扰动运算
static final int spread(int h) {
// 将原hash与原hash的高16位进行异或, 然后再和HASH_BITS进行位与预算
return (h ^ (h >>> 16)) & HASH_BITS;
}
在 table 的长度较小的时候，让高位也参与运算，降低 hash冲突的概率。
获取>=c 最小2的次方数
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;
}
获取数组指定下标位置i的元素
@SuppressWarnings("unchecked")
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
使用Unsafe通过内存地址的操作来完成，Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
通过CAS将table中指定位置i设置为新值v
// c：期望值，v新值
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);
}
table数组i位置设置值v
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
tabAt获取指定hash槽
tabAt(tab, i = (n - 1) & hash)
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
getObjectVolatile#
public native Object getObjectVolatile(Object o, long offset);
此方法和上面的getObject功能类似，不过附加了’volatile’加载语义，也就是强制从主存中获取属性值。类似的方法有getIntVolatile、getDoubleVolatile等等。这个方法要求被使用的属性被volatile修饰，否则功能和getObject方法相同。
扩容标识戳
// 扩容标识戳，标识戳一致时才能参与扩容
static final int resizeStamp(int n) {
// numberOfLeadingZeros: 这个数据的二进制串中从最左边算起连续的“0”的总数量。因为int类型的数据长度为32所以高位不足的地方会以“0”填充
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
用于计数map大小的LongAdder介绍
LongAdder类是JDK1.8新增的一个原子性操作类。AtomicLong通过CAS算法提供了非阻塞的原子性操作，相比受用阻塞算法的同步器来说性能已经很好了，但是JDK开发组并不满足于此，因为非常搞并发的请求下AtomicLong的性能是不能让人接受的。
如下AtomicLong 的incrementAndGet的代码，虽然AtomicLong使用CAS算法，但是CAS失败后还是通过无限循环的自旋锁不多的尝试，这就是高并发下CAS性能低下的原因所在。源码如下：
public final long incrementAndGet() {
for (;;) {
long current = get();
long next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
高并发下N多线程同时去操作一个变量会造成大量线程CAS失败，然后处于自旋状态，导致严重浪费CPU资源，降低了并发性。既然AtomicLong性能问题是由于过多线程同时去竞争同一个变量的更新而降低的，那么如果把一个变量分解为多个变量，让同样多的线程去竞争多个资源。
LongAdder则是内部维护一个Cells数组，每个Cell里面有一个初始值为0的long型变量，在同等并发量的情况下，争夺单个变量的线程会减少，这是变相的减少了争夺共享资源的并发量，另外多个线程在争夺同一个原子变量时候，如果失败并不是自旋CAS重试，而是尝试获取其他原子变量的锁，最后当获取当前值时候是把所有变量的值累加后再加上base的值返回的。
LongAdder维护了要给延迟初始化的原子性更新数组和一个基值变量base数组的大小保持是2的N次方大小，数组表的下标使用每个线程的hashcode值的掩码表示，数组里面的变量实体是Cell类型。
Cell 类型是Atomic的一个改进，用来减少缓存的争用，对于大多数原子操作字节填充是浪费的，因为原子操作都是无规律的分散在内存中进行的，多个原子性操作彼此之间是没有接触的，但是原子性数组元素彼此相邻存放将能经常共享缓存行，也就是伪共享。所以这在性能上是一个提升。
另外由于Cells占用内存是相对比较大的，所以一开始并不创建，而是在需要时候再创建，也就是惰性加载，当一开始没有空间时候，所有的更新都是操作base变量。
构造函数
// 默认构造函数
public ConcurrentHashMap() {
}
// 带容量参数的构造函数
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
// 小于0，抛出异常
throw new IllegalArgumentException();
// 大于 最大值/2，则为容量为最大值
// 否则，取大于(initialCapacity+ initialCapacity/2 + 1)的最小2 的次方值，即如果initialCapacity为8，则cap > (8+4+1)，cap = 16
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
// 带初始集合数据参数的构造函数
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
// 默认容量为16
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
// 容量和负载因子
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
// concurrencyLevel，并发线程数
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel)
// 初始容量参数小于并发线程数，将初始容量参数赋值为并发线程数
initialCapacity = concurrencyLevel;
// 计算数组长度
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
ConcurrentHashMap构造函数的负载因子 与hashMap的负载因子不同。ConcurrentHashMap构造中的负载因子的作用是，与initialCapacity一起确定ConcurrentHashMap容量的大小，后续扩容使用的都是默认0.75的负载因子进行扩容
put()-方法入口
public V put(K key, V value) {
return putVal(key, value, false);
}
putVal()-添加节点
// put 和 putIfAbsent的实现
final V putVal(K key, V value, boolean onlyIfAbsent) {
// null键或null值，抛出异常
if (key == null || value == null) throw new NullPointerException();
// 扰动运算，将key的hash值本身与hash值的高16位进行异或, 然后在与32位的1进行位与预算, 得出新的hash值
int hash = spread(key.hashCode());
int binCount = 0;
// 自旋
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// ConcurrentHashMap初始化是懒汉式，初次put时, 没有初始化table, 所以先初始化table
if (tab == null || (n = tab.length) == 0)
// 初始化table
tab = initTable();
// n为数组长度, 将hash值与(数组长度 - 1)进行位与预算, 获取该下标的node
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果数组在该下标的位置没有node, 通过CAS将key和value构造成node填入数组内
// 参数1: 数组
// 参数2: 下标
// 参数3: 期望值
// 参数4: 要设置的新值
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
// CAS操作成功，退出循环
break;
}
// 如果该下标位置有node, 且该node的hash值为moved(即-1), 说明当前concurrenthashmap正在扩容, 那么本次操作将会帮助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
// node存在, 并且该下标位置不是扩容状态
// 扩容是一个下标一个下标进行的, 此时当前concurrenthashmap也可能在扩容, 但是还没处理到该下标, 该下标可以进行put操作, 并且该线程不会帮助扩容
V oldVal = null;
// 锁住该node, 该node就是该下标位置的第一个node
synchronized (f) {
// 再次确认该下标加锁前该node有没有发生变化
if (tabAt(tab, i) == f) {
// fh是该node的hash值, 如果hash值为正数, 说明该下标是按照链表存储的
if (fh >= 0) {
binCount = 1;
// 遍历该链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果节点e的hash值等于hash, 并且key值也相等, 则需要更新value
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
// 更新value
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;
}
}
}
// fh<0 代表该下标位置存储的是红黑树, 因为上面已经判断未在扩容了, 所以这里只能是红黑树
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;
}
}
}
}
// binCount为table数组在该下标中的节点个数，
// 判断binCount是否为0，为0则表示首节点发生变化，不需要做链表转红黑树
// 不为0，则跳出循环后判断binCount是否满足转换为红黑树的条件
if (binCount != 0) {
// 如果binCount >= 8, 则将该节点变为红黑树
// 新增的情况，在链表尾部添加节点完成直接退出循环, 并未将binCount+1, 所以其实是9个节点时开始转红黑树
// 如果刚好更新第8个节点，更新完也会转红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 总node数+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) {
// table为空时, 如果sizeCtl<0, 说明有另一个线程在初始化table
if ((sc = sizeCtl) < 0)
// 放弃CPU执行权, 重新竞争CPU执行权
Thread.yield();
// sizeCtl>0, 说明没有线程竞争初始化table, 使用CAS将sizeCtl设置为-1, 代表初始化中
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 再次判断table是否为空
if ((tab = table) == null || tab.length == 0) {
// sc为构造函数为sizeCtl赋的值, 如果使用的是默认构造函数, 则sc为0, 使用默认的容量为16, 反之则使用
// 计算数组长度
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 初始化长度为n的table
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// sc重新赋值为数组长度的0.75倍
sc = n - (n >>> 2);
}
} finally {
// 更新sizeCtl
sizeCtl = sc;
}
break;
}
}
return tab;
}
while中循环设置sizeCtl并初始化数组
如果sizeCtl<0 说明其他线程已经在初始化，说明本线程不需要再初始化，Thread.yield();暂时让出cpu。从新获得cpu后再检测是不是已经初始化完毕
如果不小于0 ，sizeCtl>0表示初始容量。 设置成-1，向其他线程说明自己已经在初始化
初始化完毕之后再把sizeCtl设置大于0，sizeCtl变为原来的四分之三
sizeCtl在初始化后存储的是扩容门槛；
扩容门槛写死的是桶数组大小的0.75倍，桶数组大小即map的容量，也就是最多存储多少个元素。
如果数组上的位置还是空，cas在数组上设置值
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break;
如果不为空，需要放入链表或者红黑树
else {
// node存在, 并且该下标位置不是扩容状态
// 扩容是一个下标一个下标进行的, 此时当前concurrenthashmap也可能在扩容, 但是还没处理到该下标, 该下标可以进行put操作, 并且该线程不会帮助扩容
V oldVal = null;
// 锁住该node, 该node就是该下标位置的第一个node
synchronized (f) {
// 再次确认该下标加锁前该node有没有发生变化
if (tabAt(tab, i) == f) {
// fh是该node的hash值, 如果hash值为正数, 说明该下标是按照链表存储的
if (fh >= 0) {
binCount = 1;
// 遍历该链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果节点e的hash值等于hash, 并且key值也相等, 则需要更新value
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
// 更新value
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;
}
}
}
// fh<0 代表该下标位置存储的是红黑树, 因为上面已经判断未在扩容了, 所以这里只能是红黑树
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;
}
}
}
}
// binCount为table数组在该下标中的节点个数，
// 判断binCount是否为0，为0则表示首节点发生变化，不需要做链表转红黑树
// 不为0，则跳出循环后判断binCount是否满足转换为红黑树的条件
if (binCount != 0) {
// 如果binCount >= 8, 则将该节点变为红黑树
// 新增的情况，在链表尾部添加节点完成直接退出循环, 并未将binCount+1, 所以其实是9个节点时开始转红黑树
// 如果刚好更新第8个节点，更新完也会转红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
锁头节点
在链表上找到相等值，替换，否则尾插
链表长超过8，treeifyBin
transfer()-扩容方法
扩容方法有两个入参，一个源tab，一个是扩容后的tab，首次出发扩容，进入transfer方法。扩容后的tab为空
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 根据CPU核数计算出步长, 用于分隔扩容任务, 方便其余线程帮助扩容, 最小为16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 判断nextTable是否为空, nextTable是暂时存储扩容后的node数组, 第一次进入这个方法的线程才会发现nextTable为空
// 前文提到的helpTransfer也会调用该方法, 当helpTransfer调用该方法时nextTable不为空
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 初始化nextTable为table长度的2倍
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
// 如果发生了异常, 则将sizeCtl设为Integer的最大值, 因为前文提过数组长度大于1<<30就不能再扩容了
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 将transferIndex赋值为原数组table的长度
transferIndex = n;
}
// 新数组的长度
int nextn = nextTab.length;
// ForwardingNode节点, 当某个桶位数据处理完毕后, 将此桶位设置为ForwardingNode节点
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 推进标记
boolean advance = true;
// 完成标记
boolean finishing = false; // to ensure sweep before committing nextTab
// i: 表示分配给当前线程任务执行到的数组下标; bound: 表示分配给当前线程任务的下界限制
// 自旋
for (int i = 0, bound = 0;;) {
// f: 当前数组下标的头节点; fh: 头节点的hash
Node<K,V> f; int fh;
// 该while循环的作用有两点 1.将扩容任务根据步长分块 2.确定本次循环要rehash的下标节点
while (advance) {
// nextIndex: 分配任务的开始下标; nextBound: 分配任务的结束下标
int nextIndex, nextBound;
// 条件1: --i >= bound
// true-> 表示当前任务尚未完成, 需要处理相应的下标数据
// false-> 表示当前线程任务已经完成或还未开始分配
if (--i >= bound || finishing)
advance = false;
// 前置条件: 当前任务已完成或未分配
// true-> 表示table数组所有区间都已分配完成, 设置当前线程的i为-1, 退出循环后, 执行退出迁移任务相关的逻辑
// false-> 当前table数组还有区间可以分配
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 前置条件: 当前线程需要分配任务, 当前table数组还有区间可以分配
// true-> 当前线程分配任务成功
// false-> 当前线程分配任务失败, 区间扩容任务分配给了其他线程
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 设置下个边界
bound = nextBound;
// 设置table数组下标
i = nextIndex - 1;
advance = false;
}
}
// 条件1: i < 0
// true-> 当前线程为分配区间任务, 或所分配的任务都已经执行完成, 未分配新的任务
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 任务完成状态已经设置成true, 代表所有区间任务都已经完成了
if (finishing) {
// 将临时新table设置为null
nextTable = null;
// 新table赋值为table
table = nextTab;
// 将sizeCtl设置为扩容阈值
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 将sizeCtl-1, 表示参与扩容的线程减少1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// true-> 当前线程不是最后一个退出transfer的线程
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
// 直接退出
return;
// 前置条件: 当前线程是最后一个退出transfer的线程
// 设置任务完成状态为完成
finishing = advance = true;
i = n; // recheck before commit
}
}
// 如果该下标内没有数据, 则将该下标处的节点(即为null)放入ForwardingNode, 代表该下标rehash结束
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 如果该下标处的节点的hash值为-1(即ForwardingNode的hash值), 代表已经rehash结束, 继续下一次循环
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 真正开始扩容, 锁住该下标的第一个node
synchronized (f) {
// 再次判断该node是否发生改变
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// 如果该node的hash值>=0, 代表该node是链表节点
if (fh >= 0) {
// 将该node的hash值和原数组长度进行位与运算
int runBit = fh & n;
Node<K,V> lastRun = f;
// 遍历链表, runBit为末尾节点的位与运算结果, lastRun是和末尾节点位与运算结果一致的最后一个节点
// 即lastRun之后的节点不需要再二次遍历, 遍历到此时, 直接将lastRun之后的链表放入新数组中即可, 因为位与运算结果一致
// 遍历完成后, 旧链表在新数组中的下标位置为i, i+n, ln为新数组下标i的末尾节点, hn为新数组下标i+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 (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
// 遍历链表, 将链表内的node重新分配到新nextTable的i位置和i+n位置
// 原始的链表会倒序分到两个下标内, 越靠后的node在新链表里越靠前
// 遍历完成后, ln为新nextTable中i位置的头节点, hn为新nextTable中i+n位置的头节点
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);
}
// 更新新的nextTab, 并将原table的该下标位置放入ForwardingNode
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
// 该node为红黑树
else if (f instanceof TreeBin) {
// 将链表节点转化为红黑树节点
TreeBin<K,V> t = (TreeBin<K,V>)f;
// 在新table中i位置的红黑树节点
TreeNode<K,V> lo = null, loTail = null;
// 在新table中i+n位置的红黑树节点
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
// 红黑树节点是维护了一个链表的，e.next即可取出后继节点
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;
}
}
// 如果树的node数量<=6, 则将红黑树转换为链表
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;
// 将新树或链表放到新的table对应的下标里
// 并将原table的该下标位置放入ForwardingNode
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
（1）新桶数组大小是旧桶数组的两倍（如果nextTab为空）；
（2）遍历旧桶数组，迁移元素先从靠后的桶开始；
（3）迁移完成的桶在里面放置一ForwardingNode类型的元素，标记该桶迁移完成；
（4）迁移时根据hash&n是否等于0把桶中元素分化成两个链表或树；
（5）低位链表（树）存储在原来的位置；
（6）高们链表（树）存储在原来的位置加n的位置；
（7）迁移元素时会锁住当前桶，也是分段锁的思想；
（8）完成迁移之后会将table设置为扩容后的hash桶
table = nextTab;
helpTransfer()-帮助扩容
helpTransfer 会在put，remove,get时发现当前槽的头节点为MOVE状态时 也就是已经转换为ForwardingNode,代表当前节点已经转移完毕，整个ConcurrentHashMap还正在扩容，说明整个concurrenHashMap正在扩容。那么进入helpTransfer方法，协助进行扩容，直到扩容完成，那么如果当前需要操作的节点还不是ForwardingNode即还没有完成扩容操作，那么会直接使用源tab，进行操作，对于写操作，也就是说，扩容期间，除了锁住头节点的槽，和已经扩容完成的节点，其他节点依然正常读写。不会因为访问这些节点进入协助扩容！，可见ConcurrentHashMap对锁粒度的控制十分细。
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 如果table不为空并且该下标的第一个node为ForwardingNode(ForwardingNode是一个代表扩容完毕的特殊node)
// 并且存储扩容后数据的nextTable不为空
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 获取扩容标识戳
int rs = resizeStamp(tab.length);
// sizeCtl < 0代表正在扩容
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 条件1: 判断当前线程获取到的扩容标识戳与通过sc计算得出的是否一致，不一致则不是同一批次扩容，退出循环
// 条件2: JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs << 16 ) + 1, true-> 表示扩容完毕，当前线程不需要再参与进来了 false-> 扩容还在进行中，当前线程可以参与(其他人的解释，楼主不太懂)
// 条件3: JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs<<16) + MAX_RESIZERS(其他人的解释，楼主不太懂)
// 条件4: transferIndex表示扩容剩余任务区间，<=0则表示扩容任务已分配完毕
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 通过CAS将SIZECTL + 1
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 扩容
transfer(tab, nextTab);
break;
}
}
// 返回扩容后的table
return nextTab;
}
return table;
}
判断条件为必须为已扩容完成的ForwardingNode，从ForwardingNode中获取nextTab。如果补上扩容完成的ForwardingNode，那么直接返回tab。
这是因为当前hash槽在没有变为ForwardingNode之前，当前tab的节点还没有被改变，那么直接是使用当前。
helpTransfer本还是调用，transfer方法进行扩容，调用transfer时。会传一个nextTab进去，ForwardingNode节点中存储了nextTab。，进入transfer方法后，依然是每个hash槽进行遍历，对于已经完成的节点直接跳过。
红黑数相关操作
tryPresize
看回之前的 treeifyBin 当map的length不足64时，扩容，而不是转化成红黑树
private final void tryPresize(int size) {
//如果大小为MAXIMUM_CAPACITY最大总量的一半，那么直接扩容为MAXIMUM_CAPACITY，否则计算最小幂次方
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
//如果sizeCtl为正数或0
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
//如果table还未进行初始化
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
//cas修改sizeCtl为-1，表示table正在进行初始化
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
//确认其他线程没有对table修改
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
//0.75*n
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
//如果扩容大小没有达到阈值，或者超过最大容量
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) {
/**生成表的生成戳，每个n都有不同的生成戳
* static final int resizeStamp(int n) {
* return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
* }
* Integer.numberOfLeadingZeros(n)在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量
* 例如 n为16 0001 0000 则Integer.numberOfLeadingZeros(n)为27，因为n为2的幂次方，因此不同的n此结果也不同
* 然后与(1 << (RESIZE_STAMP_BITS - 1)) | ，相当于2^15 | n中0的个数。
* (因此其左移16位后符号位为1，结果肯定是个负数)
*/
int rs = resizeStamp(n);
if (sc < 0) {
Node<K,V>[] nt;
/**1.第一个判断 sc右移RESIZE_STAMP_SHIFT位，也就是比较高ESIZE_STAMP_BITS位生成戳和rs是否相等
* 相等则代表是同一个n，是在同一容量下进行的扩容，
* 2.第二个和第三个判断 判断当前帮助扩容线程数是否已达到MAX_RESIZERS最大扩容线程数
* 3.第四个和第五个判断 为了确保transfer()方法初始化完毕
*/
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值，作为扩容的发起，rs左移RESIZE_STAMP_SHIFT位+2
* 上面说了，左移RESIZE_STAMP_SHIFT位，肯定是个负数，代表有一个线程正在进行扩容
* 此时sizeCtl高RESIZE_STAMP_BITS位为生成戳，低RESIZE_STAMP_SHIFT位为扩容线程数
*/
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
TreeBin()-红黑树链表节点构造函数
将链表转换为红黑树
TreeBin(TreeNode<K,V> b) {
// 设置节点hash为-2, 表示此节点是TreeBin节点
super(TREEBIN, null, null, null);
// 将b赋值为first，表示红黑树链表的头节点
this.first = b;
// 用来表示红黑树根节点
TreeNode<K,V> r = null;
// x表示遍历的当前插入节点
for (TreeNode<K,V> x = b, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
// 设置当前插入节点的左右子树为null
x.left = x.right = null;
// 第一次遍历，r为空，设置当前插入节点为根节点，赋值给r
if (r == null) {
x.parent = null;
x.red = false;
r = x;
}
// r不为null，则非第一次遍历
else {
// k表示插入节点的key
K k = x.key;
// h表示插入节点的hash
int h = x.hash;
// kc表示插入节点key的class类型
Class<?> kc = null;
// p 表示查找插入节点的父节点
// 从根节点开始遍历，查找插入节点应该放置的位置
for (TreeNode<K,V> p = r;;) {
// dir的值为-1或1, -1表示插入节点的hash值大于当前p节点的hash; 1表示插入节点的hash值小于当前p节点的hash
// ph p节点的hash
int dir, ph;
// 临时节点p的key
K pk = p.key;
// 插入节点的hash值小于当前节点
if ((ph = p.hash) > h)
// 插入节点可能需要插入到当前节点的左子节点 或者继续在左子树上查找
dir = -1;
else if (ph < h)
// 插入节点需要插入到当前节点的右子节点 或者继续在右子树上查找
dir = 1;
// 走到这里, 说明当前插入节点的hash与当前节点的hash一致
// comparableClassFor: 判断k是否Comparable接口的实现
// compareComparables: 通过Comparable接口的compareTo方法判断大小
// 如果(节点的Key的Class为null, 且不是Comparable接口的实现), 或通过compareTo比较为0, 即无法通过Comparable相关方法来比较, 在这里做最终排序, 最终拿到的dir一定不是0, 是-1或1
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
// xp表示插入节点的父节点
TreeNode<K,V> xp = p;
// 根据dir的值获取p的左子节点或者右子节点, 如果不为null, 则继续向下搜索
// 如果为null, 则当前p即为插入节点的父节点
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 设置插入节点的父节点为当前节点
x.parent = xp;
// 小于p节点, 需要插入到p节点的左子节点
if (dir <= 0)
xp.left = x;
else
// 大于p节点, 需要插入到p节点的右子节点
xp.right = x;
// 重新平衡红黑树
r = balanceInsertion(r, x);
break;
}
}
}
}
// 将r节点赋值给TreeBin对象的root引用
this.root = r;
// 进行递归不变检验
assert checkInvariants(root);
}
putTreeVal()-将节点插入到红黑树中
final TreeNode<K,V> putTreeVal(int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// 从红黑树根节点开始遍历, p表示当前遍历到的节点
for (TreeNode<K,V> p = root;;) {
// dir的值为-1或1, -1表示插入节点的hash值大于当前p节点的hash; 1表示插入节点的hash值小于当前p节点的hash
// ph: p节点的hash pk: p节点的key
int dir, ph; K pk;
// 如果根节点为null, 则插入的节点为根节点
if (p == null) {
// 新建红黑树节点并设置为根节点
first = root = new TreeNode<K,V>(h, k, v, null, null);
// 退出循环
break;
}
// 比较插入节点和当前遍历到的节点hash大小
else if ((ph = p.hash) > h)
// 插入节点的hash 小于 当前遍历节点, dir为-1
dir = -1;
else if (ph < h)
dir = 1;
// 走到这里说明hash值相等
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
// 如果key相等, 即为更新, 返回当前遍历的节点
return p;
// 如果(节点的Key的Class为null, 且不是Comparable接口的实现), 或通过compareTo比较为0, 即无法通过Comparable相关方法来比较
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一定不是0, 是-1或1
dir = tieBreakOrder(k, pk);
}
// xp为插入节点x的父节点(xparent), 中间遍历, 用于下面给x的父节点赋值
TreeNode<K,V> xp = p;
// 根据dir判断向左还是向右遍历, 如果子节点为null, 则子节点即为x的插入位置
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);
// 如果之前的头节点不为null, 设置之前的头节点的前驱指针为新增节点
if (f != null)
f.prev = x;
// dir<=0, 设置为左子节点
if (dir <= 0)
xp.left = x;
// dir>0, 设置为右子节点
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;
}
addCount()-增加node节点总数，统计map大小
原理同之前将的LongAdder
// 增加node总数的addCount方法, 该方法满足条件时会扩容
// put方法: x: 1, check: table在当前下标中元素个数
// remove方法: x: -1, check: -1
private final void addCount(long x, int check) {
// as: LongAdder.cells
// b: LongAdder.baseCount
// s: table数组中元素的数量
CounterCell[] as; long b, s;
// 条件1: true->表示cells已经初始化了, 当前线程应该去通过hash值查找合适的cells去累加数据
// false->表示当前线程应该将数据累加到base
// 条件2: false->表示写base成功, 数据累加到base中, 当前竞争不激烈, 不需要创建cells
// true->表示写base失败, 与其他线程在base上发生竞争, 当前线程应该尝试去创建cells
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
// 进入该if的情况
// 1. 条件1为true, 表示cells已经初始化, 需要查找合适的cells
// 2. 条件2为true, 表示写base失败, 当前线程尝试去创建cells
// a: 表示当前线程hash查找到的cell; v: 表示当前线程写cell是的期望值; m: 表示当前cells数组的长度
CounterCell a; long v; int m;
// true: 未发生锁竞争; false: 发生锁竞争
boolean uncontended = true;
// 条件1: as == null || (m = as.length - 1) < 0
// true->表示cells未初始化, 当前线程是通过写base失败进来的, 需要调用fullAddCount去扩容或重试
// 条件2: (a = as[ThreadLocalRandom.getProbe() & m]) == null, 前置条件cells已经初始化了
// true->表示当前线程命中的cell为空, 需要当前线程进入fullAddCount去初始化cell
// 条件3: !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
// false->表示当前线程通过CAS更新当前命中的cell成功
// true->表示当前线程通过CAS更新失败, 需要进入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);
// 不再参与扩容逻辑, 直接返回
return;
}
if (check <= 1)
// table在当前下标中元素个数 < 1, 不需要扩容
return;
// 获取当前table元素个数, 这是一个期望值
s = sumCount();
}
// ****************** 判断扩容 ******************
// 前置条件, 是put操作调用的addCount
if (check >= 0) {
// tab: 当前table数组; nt: nextTable; n: table数组长度; sc: sizeCtl的临时值
Node<K,V>[] tab, nt; int n, sc;
// 条件1: s >= (long)(sc = sizeCtl)
// true-> 1.当前sizeCtl为一个负数, 表示正在扩容中. -1: 当前table正在初始化; 其他负数: 表示当前table数组正在进行扩容, 高16位表示扩容的标识戳, 低16位表示1+nThread, 当前参与并发扩容的线程数量
// 2.当前sizeCtl为一个正数, 表示扩容阈值
// false-> 表示当前table尚未达到扩容条件
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 获取扩容批次唯一标识戳
int rs = resizeStamp(n);
// 当前table正在扩容, 当前线程应该协助table扩容
if (sc < 0) {
// 条件1: (sc >>> RESIZE_STAMP_SHIFT) != rs
// true-> 当前线程获取到的扩容标识戳非本批次扩容
// false-> 当前线程获取到的扩容表示戳是本批次扩容
// 条件4: (nt = nextTable) == null
// true-> 表示扩容结束
// false-> 扩容进行中
// 条件5: transferIndex <= 0
// true-> 没有扩容步长, 区间任务已分配完
// false-> 还有区间任务
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 前置条件: 当前table正在扩容, 当前线程有机会参与扩容
// true-> 当前线程成功过参与到扩容任务中, 并且将sc低16位加1, 表示多一个线程参与工作
// false-> 1. 当前很多线程尝试修改, 当前线程未修改成功
// 2. 已经参与扩容任务的线程修改了sizectl
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 条件成立, 说明当前线程是触发扩容的第一个线程, 在transfer中做一些准备工作
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
// 计算总node数, 用于下次while循环
s = sumCount();
}
}
}
get方法
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 进行扰动运算，获取新的hashCode
int h = spread(key.hashCode());
// 如果table数组不为空, 长度不为空, 并且可以获取table下标的头节点不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 如果hash值相等, key值相等, 该头节点即为要找的node, 返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 如果头节点的hash值<0, 分为两种情况
// -1为FWD, 说明当前table正在扩容, 调用FWD的find方法
// -2为TreeBin, 调用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;
}
查看find方法
find()-ForwardingNode的查找方法
Node<K,V> find(int h, Object k) {
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
// n为nextTable数组的长度
// e为在nextTable中重新定位hash对应的头节点
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (;;) {
// e节点类型: node类型, TreeBin类型, ForwardingNode类型
int eh; K ek;
// node类型的处理
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
// eh<0分两种情况, TreeBin类型, ForwardingNode类型
if (eh < 0) {
// ForwardingNode类型的处理, 调用ForwardingNode的find方法, 即自身方法
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
// TreeBin类型的处理, 调用红黑树的find方法
return e.find(h, k);
}
// 继续下次循环
if ((e = e.next) == null)
return null;
}
}
}
在正在扩容中的临时表nextTable中查找
find()-TreeBin的查找方法
final Node<K,V> find(int h, Object k) {
if (k != null) {
// 遍历红黑树链表, e为当前遍历到的节点
for (Node<K,V> e = first; e != null; ) {
// s: lock的临时状态 ek: 当前节点e的key
int s; K ek;
// WAITER|WRITER, 0010 | 0001 = 0011
// true-> 当前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;
}
// 前置条件: 当前TreeBin没有等待者线程或者写锁
// 通过CAS添加读锁, true-> 添加读锁成功
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;
// U.getAndAddInt(this, LOCKSTATE, -READER) == (READER|WAITER)
// 1. 当前线程查询红黑树结束, 释放当前线程的读锁, 就是将lockstate - 4
// READER|WAITER: 0100 | 0010 = 0110, 如果lockState为0110, 表示当前只有一个线程在读, 且有一个线程在等待
// 当前读线程为TreeBin中的最后一个读线程
// waiter != null, 说明有一个写线程在等待读操作完毕
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
// 唤醒写线程
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}
remove方法
/**
* Implementation for the four public remove/replace methods:
* Replaces node value with v, conditional upon match of cv if
* non-null. If resulting value is null, delete.
*/
final V replaceNode(Object key, V value, Object cv) {
int hash = spread(key.hashCode());
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null)
break;
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
validated = true;
for (Node<K,V> e = f, pred = null;;) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
if (value != null)
e.val = value;
else if (pred != null)
pred.next = e.next;
else
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)
break;
}
}
else if (f instanceof TreeBin) {
validated = true;
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> r, p;
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) {
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
if (value != null)
p.val = value;
else if (t.removeTreeNode(p))
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
if (validated) {
if (oldVal != null) {
if (value == null)
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
整体逻辑和hashmap的逻辑差不多，链表删除或者树删除，如果正在扩容那么helpTransfer，等待扩容完成再删除，但是map并没有缩容的方法，阔容之后，即使删除元素，容量也不会减少了
为什么hashmap中允许key或者value为null？而concurrenrtHashMap不允许key或者value为null
map.get(key)的时候，如果返回了null，那么这个null，有两重含义：
这个key从没在map中映射过；
这个key的value在设置的时候就是null
在map中，调用map.get(key)方法得到的值是null，那你无法判断这个key是在map里面没有映射过，还是这个key本身设置就null。这种情况下，在非并发安全的map中，可以通过map.contains(key)的方法来判断。但是在考虑并发安全的map中，两次调用的过程中，这个值是很有可能被改变的。
注意HashMap的key和value都可以为null。
总结
1、将当前key的hash值进行扰动运算，得出新的hash值
2、判断当前table是否初始化，未初始化则进行初始化
3、根据hash值找出数组下标，当前下标处为没有节点数据，则新增节点即可
4、对于写操作。如果当前table数组正在扩容，则帮助扩容
5.1、下标处有节点，且数组未在扩容，则锁定头节点，判断头节点的类型，如果为链表节点，遍历链表，找到了目标节点，则更新，未找到则新增；最后判断节点个数是否超过8，超过且数组长度超过64则将链表转化为红黑树。
更新第8个节点，新增第9个节点才会开始转换
5.2、如果头节点类型为红黑树节点，进行红黑树的节点插入
6、查找操作是无锁的，也不会协助扩容，如果是ForwardingNode，那么读取nextTable对应的槽位
1566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
