【❂Java集合】ConcurrentHashMap源码及底层数据结构分析
ConcurrentHashMap概览
jdk1.7中是采用Segment + HashEntry + ReentrantLock的方式进行实现的，而1.8中放弃了Segment的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现。
-
JDK1.8的实现降低锁的粒度，JDK1.7版本锁的粒度是基于Segment的，包含多个HashEntry，而JDK1.8锁的粒度就是HashEntry（首节点） -
JDK1.8版本的数据结构变得更加简单，使得操作也更加清晰流畅，因为已经使用synchronized来进行同步，所以不需要分段锁的概念，也就不需要Segment这种数据结构了，由于粒度的降低，实现的复杂度也增加了 -
JDK1.8使用红黑树来优化链表，基于长度很长的链表的遍历是一个很漫长的过程，而红黑树的遍历效率是很快的，代替一定阈值的链表。
JDK 1.7 数据结构图
JDK1.8 数据结构图
先了解一下Unsafe
Unsafe类相当于是一个java语言中的后门类，提供了硬件级别的原子操作，所以在一些并发编程中被大量使用。jdk已经作出说明，该类对程序员而言不是一个安全操作，实际项目中请谨慎使用。
这里并不系统讲解Unsafe的所有功能，只介绍和接下来内容相关的操作：
1）arrayBaseOffset：获取数组的基础偏移量
2）arrayIndexScale：获取数组中元素的偏移间隔，要获取对应索引的元素，将索引号和该值相乘，获得数组中指定角标元素的偏移量
3）getObjectVolatile：获取对象上的属性值或者数组中的元素
4）getObject：获取对象上的属性值或者数组中的元素，已过时
5）putOrderedObject：设置对象的属性值或者数组中某个角标的元素，更高效
6）putObjectVolatile：设置对象的属性值或者数组中某个角标的元素
7）putObject：设置对象的属性值或者数组中某个角标的元素，已过时
代码演示：
public class Test02 {
public static void main(String[] args) throws Exception {
Integer[] arr = {2,5,1,8,10};
//获取Unsafe对象
Unsafe unsafe = getUnsafe();
//获取Integer[]的基础偏移量
int baseOffset = unsafe.arrayBaseOffset(Integer[].class);
//获取Integer[]中元素的偏移间隔
int indexScale = unsafe.arrayIndexScale(Integer[].class);
//获取数组中索引为2的元素对象
Object o = unsafe.getObjectVolatile(arr, (2 * indexScale) + baseOffset);
System.out.println(o); //1
//设置数组中索引为2的元素值为100
unsafe.putOrderedObject(arr,(2 * indexScale) + baseOffset,100);
System.out.println(Arrays.toString(arr));//[2, 5, 100, 8, 10]
}
//反射获取Unsafe对象
public static Unsafe getUnsafe() throws Exception {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
return (Unsafe) theUnsafe.get(null);
}
}图解说明：
ConcurrentHashMap源码分析（JDK 1.7版）
在JDK1.7版本中，ConcurrentHashMap的数据结构是由一个Segment数组和多个HashEntry组成，如下图所示：
Segment数组的意义就是将一个大的table分割成多个小的table来进行加锁，也就是锁分离技术，而每一个Segment元素存储的是HashEntry数组+链表，这个和HashMap的数据存储结构一样。
Java 7 的ConcurrentHashMap由很多个 Segment 组合，而每一个 Segment 是一个类似于 HashMap 的结构，所以每一个 HashMap 的内部可以进行扩容。但是 Segment 的个数一旦初始化就不能改变，默认 Segment 的个数是 16 个，你也可以认为 ConcurrentHashMap 默认支持最多 16 个线程并发。
ConcurrentHashMap中保存了一个默认长度为16的Segment[]，每个Segment元素中保存了一个默认长度为2的HashEntry[]，我们添加的元素，是存入对应的Segment中的HashEntry[]中。所以ConcurrentHashMap中默认元素的长度是32个，而不是16个。
源码如下：
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
private static final long serialVersionUID = 7249069246763182397L;
/**
* table 的默认初始化容量
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* 默认负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 默认并发级别，即Segment[]数组的大小
*/
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 每个Segment内HashEntry数组的最大长度
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 每个segment内HashEntry数组的最小长度
*/
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
/**
* Segment数组的最大长度
*/
static final int MAX_SEGMENTS = 1 << 16;
/**
* 尝试次数
* ConcurrentHashMap 在执行 size() 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
* retries 初始值为 -1，因此尝试次数为 3。
* 如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
*/
static final int RETRIES_BEFORE_LOCK = 2;
private static class Holder {
static final boolean ALTERNATIVE_HASHING;
static {
// Use the "threshold" system property even though our threshold
// behaviour is "ON" or "OFF".
String altThreshold = java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction(
"jdk.map.althashing.threshold"));
int threshold;
try {
threshold = (null != altThreshold)
? Integer.parseInt(altThreshold)
: Integer.MAX_VALUE;
// disable alternative hashing if -1
if (threshold == -1) {
threshold = Integer.MAX_VALUE;
}
if (threshold < 0) {
throw new IllegalArgumentException("value must be positive integer.");
}
} catch (IllegalArgumentException failed) {
throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
}
ALTERNATIVE_HASHING = threshold <= MAXIMUM_CAPACITY;
}
}
private transient final int hashSeed = randomHashSeed(this);
private static int randomHashSeed(ConcurrentHashMap instance) {
if (sun.misc.VM.isBooted() && Holder.ALTERNATIVE_HASHING) {
return sun.misc.Hashing.randomHashSeed(instance);
}
return 0;
}
// segmentShift & segmentMask 的作用与 HashMap 中的 hash & (length-1) 方法类似，用于定位具体的 Segment[i]，
// 具体使用如下：(h >>> segmentShift) & segmentMask。
/**
* 用来计算索引的掩码值
*/
final int segmentMask;
/**
* 用来计算segments数组索引的位移量
*/
final int segmentShift;
/**
* segments数组
*/
final Segment<K, V>[] segments;
transient Set<K> keySet;
transient Set<Map.Entry<K, V>> entrySet;
transient Collection<V> values;
/**
* Segment分段的数组元素类型
* 与HashMap的Entry作用一致，只是使用了Unsafe来提高读写速度
*/
static final class HashEntry<K, V> {
final int hash;
final K key;
volatile V value;
volatile HashEntry<K, V> next;
HashEntry(int hash, K key, V value, HashEntry<K, V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
// 在本对象的next成员的偏移地址处放入n
final void setNext(HashEntry<K, V> n) {
UNSAFE.putOrderedObject(this, nextOffset, n);
}
static final sun.misc.Unsafe UNSAFE;
// next成员的偏移地址
static final long nextOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = HashEntry.class;
// 得到next成员在对象中的偏移量，用来进行链接操作
// 利用UnSafe类可以通过直接操作内存来提高速度
nextOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("next"));
} catch (Exception e) {
throw new Error(e);
}
}
}
static final <K, V> HashEntry<K, V> entryAt(HashEntry<K, V>[] tab, int i) {
return (tab == null) ? null :
(HashEntry<K, V>) UNSAFE.getObjectVolatile
(tab, ((long) i << TSHIFT) + TBASE);
}
//使用UNSAFE直接操作内存，将HashEntry对象添加到HashEntry[]中。
static final <K, V> void setEntryAt(HashEntry<K, V>[] tab, int i,
HashEntry<K, V> e) {
// 内存操作
UNSAFE.putOrderedObject(tab, ((long) i << TSHIFT) + TBASE, e);
}
private int hash(Object k) {
int h = hashSeed;
if ((0 != h) && (k instanceof String)) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// Spread bits to regularize both segment and index locations,
// using variant of single-word Wang/Jenkins hash.
h += (h << 15) ^ 0xffffcd7d;
h ^= (h >>> 10);
h += (h << 3);
h ^= (h >>> 6);
h += (h << 2) + (h << 14);
return h ^ (h >>> 16);
}
/**
* Segment 定义
* 继承了ReentrantLock类，ReentrantLock和synchronized都是可重入的独占锁，
* 只允许线程互斥的访问临界区，这意味着每个Segment都可以当做一个锁，
* 每把锁只锁住整个容器中的部分数据，这样不影响线程访问其他的数据，当然如果是对全局改变时会锁定所有的Segment段。
*/
static final class Segment<K, V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
//最大尝试次数达到限制进入加锁等待状态(对最大尝试次数，目前的实现单核次数为1，多核为64)
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
//segment内部的哈希表，访问HashEntry，通过具有volatile的entryAt、setEntryAt方法
transient volatile HashEntry<K, V>[] table;
//Segment的哈希表中的HashEntry的数量
transient int count;
//修改次数
transient int modCount;
//哈希表中的扩容阈值
transient int threshold;
//哈希表中的负载因子，所有的Segments中的这个值相等，这么做是为了避免需要连接到外部Object
final float loadFactor;
Segment(float lf, int threshold, HashEntry<K, V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
//segment对象中其实还是数组+链表的组合,新的元素最终还是要放到HashEntry
//只是当前需要保证只有一个线程去做put操作
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//tryLock() 尝试获取锁 会立即返回true或false,不阻塞 lock阻塞
//在往该 segment 写入前，需要先获取该 segment 的独占锁
HashEntry<K, V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value); //加锁
V oldValue;
try {
// 这个是 segment 内部的数组
HashEntry<K, V>[] tab = table;
// 再利用 hash 值，求应该放置的数组下标
int index = (tab.length - 1) & hash;
// 获取数组该位置处的链表的表头赋值给first
HashEntry<K, V> first = entryAt(tab, index);
// 下面这串 for 循环虽然很长，不过也很好理解，想想该位置没有任何元素和已经存在一个链表这两种情况
for (HashEntry<K, V> e = first; ; ) {
//匹配到key对应的HashEntry，更新HashEntry.value的值。
if (e != null) {
K k;
//判断hash值和key是否和结点的相等
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
//存旧值
oldValue = e.value;
if (!onlyIfAbsent) {
//覆盖旧值
e.value = value;
++modCount;
}
//跳出循环
break;
}
// 继续顺着链表走
e = e.next;
} else { //没有匹配到对应的HashEntry
// 将新增的节点与first做关联(头插法)。
// 将scanAndLockForPut()方法返回的node节点与first做关联，作用相当于创建HashEntry对象时传入next值。
if (node != null)
node.setNext(first);
else
//此处是获取到锁的逻辑，直接创建HashEntry对象,包装key、value。
node = new HashEntry<K, V>(hash, key, value, first);
int c = count + 1;
// 判断是否扩容(Segment[]初始化完后不能扩容，Segment内的HashEntry[]可以扩容)。
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node); //扩容+数据迁移，传入的新增node会在最后采用头插法添加进HashEntry[]中。
else
//没有达到阈值，将 node 放到数组 tab 的 index 位置，
//其实就是将新的节点设置成原链表的表头
setEntryAt(tab, index, node); //头插法
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
// 解锁
unlock();
}
return oldValue;
}
//老的链表中的节点适用到新数组中，为了优化效率，可以对已有链表进行遍历，对于老的oldTable中的每个HashEntry，
// 从头结点开始遍历，找到第一个后续所有节点在新table中index保持不变的节点fv，
// 假设这个节点新的index为newIndex，那么直接newTable[newIndex]=fv，
// 即可以直接将这个节点以及它后续的链表中内容全部直接复用copy到newTable中，
// 这样最好的情况是所有oldTable中对应头结点后跟随的节点在newTable中的新的index均和头结点一致，
// 那么就不需要创建新节点，直接复用即可。
// 最坏情况当然就是所有节点的新的index全部发生了变化，那么就全部需要重新依据k,v创建新对象插入到newTable中
private void rehash(HashEntry<K, V> node) { // 方法参数上的 node 是这次扩容后，需要添加到新的数组中的数据
HashEntry<K, V>[] oldTable = table; //旧表指针oldTable
int oldCapacity = oldTable.length; //保存旧容量
int newCapacity = oldCapacity << 1; //扩容为旧数组的2倍
threshold = (int) (newCapacity * loadFactor); //新的阈值
HashEntry<K, V>[] newTable =
(HashEntry<K, V>[]) new HashEntry[newCapacity]; // 创建新数组
// 新的掩码，如从 16 扩容到 32，那么 sizeMask 为 31，对应二进制 ‘000...00011111’
int sizeMask = newCapacity - 1;
for (int i = 0; i < oldCapacity; i++) { //遍历老链表
// e 是链表的第一个元素
HashEntry<K, V> e = oldTable[i];
if (e != null) {
HashEntry<K, V> next = e.next; //辅助指针
// 计算应该放置在新数组中的位置，
//新位置为 原下标或者原下标+旧容量
int idx = e.hash & sizeMask;
if (next == null)
// 该链表处只有一个元素，那比较好办
//直接在新表的对应位置放入结点
newTable[idx] = e;
else {
HashEntry<K, V> lastRun = e; // e 是链表表头 赋值给lastRun
// idx 是当前链表的头结点 e 的新位置
int lastIdx = idx;
// 下面这个 for 循环会找到一个 lastRun 节点，这个节点之后的所有元素是将要放到一起的
//遍历后续链表(头表的下一个结点)
for (HashEntry<K, V> last = next;
last != null;
last = last.next) {
//计算新位置
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
// 将 lastRun 及其之后的所有节点组成的这个链表放到 lastIdx 这个位置
newTable[lastIdx] = lastRun;
// 下面的操作是处理 lastRun 之前的节点，
//这些节点可能分配在另一个链表中，也可能分配到上面的那个链表中
for (HashEntry<K, V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K, V> n = newTable[k];
newTable[k] = new HashEntry<K, V>(h, p.key, v, n);
}
}
}
}
// 将新来的 node 放到新数组中刚刚的 两个链表之一 的 头部
int nodeIndex = node.hash & sizeMask;
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
//获取写入锁: scanAndLockForPut
//其中的核心思想就是通过MAX_SCAN_RETRIES控制自旋次数，防止无限制的重复自旋浪费资源。
//这个方法很显然见名知意，它的作用就是遍历获取锁然后进行数据插入，
//自旋锁是指尝试获取的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上下文切换的消耗,缺点是会消耗CPU性能
private HashEntry<K, V> scanAndLockForPut(K key, int hash, V value) {
// 根据key的hash值查找头节点，头结点可能为null。
HashEntry<K, V> first = entryForHash(this, hash);
HashEntry<K, V> e = first;
HashEntry<K, V> node = null;
int retries = -1;
//如果尝试加锁失败，那么就对segment[hash]对应的链表进行遍历找到需要put的这个entry所在的链表中的位置，
//这里之所以进行一次遍历找到坑位，主要是为了通过遍历过程将遍历过的entry全部放到CPU高速缓存中，
//这样在获取到锁了之后，再次进行定位的时候速度会十分快，这是在线程无法获取到锁前并等待的过程中的一种预热方式。
while (!tryLock()) {
HashEntry<K, V> f; // to recheck first below
//获取锁失败，初始时retries=-1必然开始先进入第一个if
if (retries < 0) {
//e=null代表两种意思，
//第一种就是遍历链表到了最后，仍然没有发现指定key的entry；
//第二种情况是刚开始时entryForHash(通过hash找到的table中对应位置链表的结点)找到的HashEntry就是空的
if (e == null) {
//当然这里之所以还需要对node==null进行判断，是因为有可能在第一次给node赋值完毕后，
// 然后预热准备工作已经搞定，然后进行循环尝试获取锁，在循环次数还未达到<2>64次以前，
// 某一次在条件<3>判断时发现有其它线程对这个segment进行了修改，那么retries被重置为-1，
// 从而再一次进入到<1>条件内，此时如果再次遍历到链表最后时，因为上一次遍历时已经给node赋值过了，
// 所以这里判断node是否为空，从而避免第二次创建对象给node重复赋值。
if (node == null)
node = new HashEntry<K, V>(hash, key, value, null); //第一次会new一个HashEntry
retries = 0;
} else if (key.equals(e.key)) //遍历过程发现链表中找到了我们需要的key的坑位
retries = 0; //有key相等的直接切换到其它else
else //当前位置对应的key不是我们需要的，遍历下一个
e = e.next; //赋值链表下一元素
} else if (++retries > MAX_SCAN_RETRIES) { //重试次数,跟cpu有关系 MAX_SCAN_RETRIES为64
// 尝试获取锁次数超过设置的最大值，直接进入阻塞等待，这就是所谓的有限制的自旋获取锁，
//之所以这样是因为如果持有锁的线程要过很久才释放锁，这期间如果一直无限制的自旋其实是对cpu性能有消耗的，
//这样无限制的自旋是不利的，所以加入最大自旋次数，超过这个次数则进入阻塞状态等待对方释放锁并获取锁。
lock();
break;
// 遍历过程中，有可能其它线程改变了遍历的链表，这时就需要重新进行遍历了。
//判断是否初始化了结点 并且 判断链表头结点是否改变(1.7使用头插法)
} else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
private void scanAndLock(Object key, int hash) {
// similar to but simpler than scanAndLockForPut
HashEntry<K, V> first = entryForHash(this, hash);
HashEntry<K, V> e = first;
int retries = -1;
while (!tryLock()) {
HashEntry<K, V> f;
if (retries < 0) {
if (e == null || key.equals(e.key))
retries = 0;
else
e = e.next;
} else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
} else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f;
retries = -1;
}
}
}
final V remove(Object key, int hash, Object value) {
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K, V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K, V> e = entryAt(tab, index);
HashEntry<K, V> pred = null;
while (e != null) {
K k;
HashEntry<K, V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
if (value == null || value == v || value.equals(v)) {
if (pred == null)
setEntryAt(tab, index, next);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock();
}
return oldValue;
}
final boolean replace(K key, int hash, V oldValue, V newValue) {
if (!tryLock())
scanAndLock(key, hash);
boolean replaced = false;
try {
HashEntry<K, V> e;
for (e = entryForHash(this, hash); e != null; e = e.next) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
if (oldValue.equals(e.value)) {
e.value = newValue;
++modCount;
replaced = true;
}
break;
}
}
} finally {
unlock();
}
return replaced;
}
final V replace(K key, int hash, V value) {
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K, V> e;
for (e = entryForHash(this, hash); e != null; e = e.next) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
e.value = value;
++modCount;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
final void clear() {
lock();
try {
HashEntry<K, V>[] tab = table;
for (int i = 0; i < tab.length; i++)
setEntryAt(tab, i, null);
++modCount;
count = 0;
} finally {
unlock();
}
}
}
static final <K, V> Segment<K, V> segmentAt(Segment<K, V>[] ss, int j) {
long u = (j << SSHIFT) + SBASE;
return ss == null ? null :
(Segment<K, V>) UNSAFE.getObjectVolatile(ss, u);
}
//创建Segment
//ConcurrentHashMap 初始化的时候会初始化第一个槽 segment[0]，对于其他槽来说，在插入第一个值的时候进行初始化。
//这里需要考虑并发，因为很可能会有多个线程同时进来初始化同一个槽 segment[k]，不过只要有一个成功了就可以
private Segment<K, V> ensureSegment(int k) {
//指向当前的Segment数组
final Segment<K, V>[] ss = this.segments;
// 计算第k个Segment的地址(一个Segment的大小为1<<SSHIFT)。
long u = (k << SSHIFT) + SBASE;
Segment<K, V> seg;
// 上面使用UNSAFE.getObject()取值时，由于Java内存模型的原因，所以其它线程已经创建，但对当前线程还不可见。
// 所以这里使用UNSAFE.getObjectVolatile()再次尝试获取。
if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
// 通过Segment[0]的Segment信息初始化其它位置的Segment。
Segment<K, V> proto = ss[0];
//容量
int cap = proto.table.length;
//负载因子
float lf = proto.loadFactor;
//计算扩容阈值
int threshold = (int) (cap * lf);
// 初始化 segment[k] 内部的数组
HashEntry<K, V>[] tab = (HashEntry<K, V>[]) new HashEntry[cap];
// 在上述的过程中，可能存在并发场景，所以这里进行recheck，避免在上面这段时间内创建了Segment。
if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u))
== null) {
//初始化
Segment<K, V> s = new Segment<K, V>(lf, threshold, tab);
// 使用 while 循环，内部用 CAS，当前线程成功设值或其他线程成功设值后，退出
while ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u))
== null) {
//用cas保证并发情况下只有一个线程能取到值
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
private Segment<K, V> segmentForHash(int h) {
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
return (Segment<K, V>) UNSAFE.getObjectVolatile(segments, u);
}
static final <K, V> HashEntry<K, V> entryForHash(Segment<K, V> seg, int h) {
HashEntry<K, V>[] tab;
return (seg == null || (tab = seg.table) == null) ? null :
(HashEntry<K, V>) UNSAFE.getObjectVolatile
(tab, ((long) (((tab.length - 1) & h)) << TSHIFT) + TBASE);
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 参数校验
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
//对并发级别做了限制 并发水平，即，Segment分段数，不能超过最大段数
concurrencyLevel = MAX_SEGMENTS;
//记录偏移量
int sshift = 0;
// segment数组大小
int ssize = 1;
// 传入的concurrencyLevel不一定是2^n。所以这里会计算出大于concurrencyLevel的最小2^n的数(类似hashMap扩容)。
while (ssize < concurrencyLevel) {
++sshift; //2的几次方=concurrencyLevel,sshift就是几
ssize <<= 1; //寻找>并发级别的最小的2的幂次方数
}
// 记录段偏移量，用于后面计算下标
this.segmentShift = 32 - sshift; // 当concurrencyLevel为默认值16时，sshift=4，得到segmentShift=28。
this.segmentMask = ssize - 1; // segmentMask为掩码，因为ssize肯定为2^n，所以ssize-1后，转换为二进制时，后面几位都为1。
// initialCapacity 是设置整个 map 初始的大小，
// 这里根据 initialCapacity 计算 Segment 数组中每个位置可以分到的大小
// 如 initialCapacity 为 64，那么每个 Segment 或称之为"槽"可以分到 4 个
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//1.假设16/16=1, 1*16<16不成立,c=1,cap=2,c>cap不成立,此时HashEntry长度为最小的2
//2.假设33/16=2, 2*16<33成立,c=3,cap=2,c>cap成立,cap*2=4,此时HashEntry长度为4
//这个算法的意义在于让初始化segment能放得下里面的HashEntry
//按照第二种假设,如果HashEntry长度仍为2,那存储的总量就是Segment的ssize*2,16*2=32,实际是33,存不下
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY; //segment数组最小长度为2或者2的倍数
while (cap < c)
cap <<= 1;
// 初始化Segment[0]位置的Segment。
Segment<K, V> s0 =
new Segment<K, V>(loadFactor, (int) (cap * loadFactor),
(HashEntry<K, V>[]) new HashEntry[cap]);
// 初始化Segment数组
Segment<K, V>[] ss = (Segment<K, V>[]) new Segment[ssize];
//把segment对象s0放入segment数组ss第0个位置
//UNSAFE基于内存操作CAS原理,针对多线程安全性
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}
public ConcurrentHashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
//传入了默认初始化容量(16)，默认负载因子(0.75f)，默认并发级别(16)
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY),
DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
putAll(m);
}
public boolean isEmpty() {
long sum = 0L;
final Segment<K, V>[] segments = this.segments;
for (int j = 0; j < segments.length; ++j) {
Segment<K, V> seg = segmentAt(segments, j);
if (seg != null) {
if (seg.count != 0)
return false;
sum += seg.modCount;
}
}
if (sum != 0L) { // recheck unless no modifications
for (int j = 0; j < segments.length; ++j) {
Segment<K, V> seg = segmentAt(segments, j);
if (seg != null) {
if (seg.count != 0)
return false;
sum -= seg.modCount;
}
}
if (sum != 0L)
return false;
}
return true;
}
public int size() {
final Segment<K, V>[] segments = this.segments;
int size;
boolean overflow;
long sum;
long last = 0L;
int retries = -1;
try {
// 遍历累加每个Segment中的size。
for (; ; ) {
// 遍历过程中如果存在增删操作影响到元素个数时，重新遍历(重试RETRIES_BEFORE_LOCK次)。
// 重试超过RETRIES_BEFORE_LOCK次后，对每个Segment加锁获取。
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
sum = 0L;
size = 0;
overflow = false;
// 遍历累加每个Segment中的size。
for (int j = 0; j < segments.length; ++j) {
Segment<K, V> seg = segmentAt(segments, j);
if (seg != null) {
//累加所有Segment的操作次数
sum += seg.modCount;
int c = seg.count;
//累加所有segment中的元素个数 size+=c
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
//当这次累加值和上一次累加值一样，证明没有进行新的增删改操作，返回sum
//第一次last为0，如果有元素的话，这个for循环最少循环两次的
if (sum == last)
break;
//记录累加的值
last = sum;
}
} finally {
//解锁
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
//溢出，返回int的最大值，否则返回累加的size
return overflow ? Integer.MAX_VALUE : size;
}
public V get(Object key) {
Segment<K, V> s; // manually integrate access methods to reduce overhead
HashEntry<K, V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// 计算得到 key 的存放位置
if ((s = (Segment<K, V>) UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K, V> e = (HashEntry<K, V>) UNSAFE.getObjectVolatile
(tab, ((long) (((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
// 如果是链表，遍历查找到相同 key 的 value。
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
public boolean containsKey(Object key) {
Segment<K, V> s; // same as get() except no need for volatile value read
HashEntry<K, V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K, V>) UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K, V> e = (HashEntry<K, V>) UNSAFE.getObjectVolatile
(tab, ((long) (((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return true;
}
}
return false;
}
public boolean containsValue(Object value) {
// Same idea as size()
if (value == null)
throw new NullPointerException();
final Segment<K, V>[] segments = this.segments;
boolean found = false;
long last = 0;
int retries = -1;
try {
outer:
for (; ; ) {
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
long hashSum = 0L;
int sum = 0;
for (int j = 0; j < segments.length; ++j) {
HashEntry<K, V>[] tab;
Segment<K, V> seg = segmentAt(segments, j);
if (seg != null && (tab = seg.table) != null) {
for (int i = 0; i < tab.length; i++) {
HashEntry<K, V> e;
for (e = entryAt(tab, i); e != null; e = e.next) {
V v = e.value;
if (v != null && value.equals(v)) {
found = true;
break outer;
}
}
}
sum += seg.modCount;
}
}
if (retries > 0 && sum == last)
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return found;
}
public boolean contains(Object value) {
return containsValue(value);
}
public V put(K key, V value) {
Segment<K, V> s;
if (value == null) //不允许value为null
throw new NullPointerException();
// 计算 key 的 hash 值, 与HashMap类似，主要是为了数据尽可能的均匀分布。
int hash = hash(key);
// 计算出该数据要存储在哪个Segment上。
int j = (hash >>> segmentShift) & segmentMask; //segmentMask=ssize-1 segment数组大小-1
// 判断Segment[j]位置上的Segment是否初始化(构造方法中只初始化了Segment[0]的元素)。
// 这里使用UNSAFE.getObject()方法取值在并发场景下不保证可见性。
if ((s = (Segment<K, V>) UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
// ensureSegment(j) 对 segment[j] 进行初始化
s = ensureSegment(j);
// 创建完Segment后，将数据添加到Segment上。
return s.put(key, hash, value, false);
}
public V putIfAbsent(K key, V value) {
Segment<K, V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K, V>) UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
s = ensureSegment(j);
return s.put(key, hash, value, true);
}
public void putAll(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}
public V remove(Object key) {
int hash = hash(key);
Segment<K, V> s = segmentForHash(hash);
return s == null ? null : s.remove(key, hash, null);
}
public boolean remove(Object key, Object value) {
int hash = hash(key);
Segment<K, V> s;
return value != null && (s = segmentForHash(hash)) != null &&
s.remove(key, hash, value) != null;
}
public boolean replace(K key, V oldValue, V newValue) {
int hash = hash(key);
if (oldValue == null || newValue == null)
throw new NullPointerException();
Segment<K, V> s = segmentForHash(hash);
return s != null && s.replace(key, hash, oldValue, newValue);
}
public V replace(K key, V value) {
int hash = hash(key);
if (value == null)
throw new NullPointerException();
Segment<K, V> s = segmentForHash(hash);
return s == null ? null : s.replace(key, hash, value);
}
public void clear() {
final Segment<K, V>[] segments = this.segments;
for (int j = 0; j < segments.length; ++j) {
Segment<K, V> s = segmentAt(segments, j);
if (s != null)
s.clear();
}
}
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null) ? ks : (keySet = new KeySet());
}
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null) ? vs : (values = new Values());
}
public Set<Map.Entry<K, V>> entrySet() {
Set<Map.Entry<K, V>> es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet());
}
public Enumeration<K> keys() {
return new KeyIterator();
}
public Enumeration<V> elements() {
return new ValueIterator();
}
abstract class HashIterator {
int nextSegmentIndex;
int nextTableIndex;
HashEntry<K, V>[] currentTable;
HashEntry<K, V> nextEntry;
HashEntry<K, V> lastReturned;
HashIterator() {
nextSegmentIndex = segments.length - 1;
nextTableIndex = -1;
advance();
}
final void advance() {
for (; ; ) {
if (nextTableIndex >= 0) {
if ((nextEntry = entryAt(currentTable,
nextTableIndex--)) != null)
break;
} else if (nextSegmentIndex >= 0) {
Segment<K, V> seg = segmentAt(segments, nextSegmentIndex--);
if (seg != null && (currentTable = seg.table) != null)
nextTableIndex = currentTable.length - 1;
} else
break;
}
}
final HashEntry<K, V> nextEntry() {
HashEntry<K, V> e = nextEntry;
if (e == null)
throw new NoSuchElementException();
lastReturned = e; // cannot assign until after null check
if ((nextEntry = e.next) == null)
advance();
return e;
}
public final boolean hasNext() {
return nextEntry != null;
}
public final boolean hasMoreElements() {
return nextEntry != null;
}
public final void remove() {
if (lastReturned == null)
throw new IllegalStateException();
ConcurrentHashMap.this.remove(lastReturned.key);
lastReturned = null;
}
}
final class KeyIterator
extends HashIterator
implements Iterator<K>, Enumeration<K> {
public final K next() {
return super.nextEntry().key;
}
public final K nextElement() {
return super.nextEntry().key;
}
}
final class ValueIterator
extends HashIterator
implements Iterator<V>, Enumeration<V> {
public final V next() {
return super.nextEntry().value;
}
public final V nextElement() {
return super.nextEntry().value;
}
}
final class WriteThroughEntry
extends AbstractMap.SimpleEntry<K, V> {
WriteThroughEntry(K k, V v) {
super(k, v);
}
public V setValue(V value) {
if (value == null) throw new NullPointerException();
V v = super.setValue(value);
ConcurrentHashMap.this.put(getKey(), value);
return v;
}
}
final class EntryIterator
extends HashIterator
implements Iterator<Entry<K, V>> {
public Map.Entry<K, V> next() {
HashEntry<K, V> e = super.nextEntry();
return new WriteThroughEntry(e.key, e.value);
}
}
final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return new KeyIterator();
}
public int size() {
return ConcurrentHashMap.this.size();
}
public boolean isEmpty() {
return ConcurrentHashMap.this.isEmpty();
}
public boolean contains(Object o) {
return ConcurrentHashMap.this.containsKey(o);
}
public boolean remove(Object o) {
return ConcurrentHashMap.this.remove(o) != null;
}
public void clear() {
ConcurrentHashMap.this.clear();
}
}
final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return new ValueIterator();
}
public int size() {
return ConcurrentHashMap.this.size();
}
public boolean isEmpty() {
return ConcurrentHashMap.this.isEmpty();
}
public boolean contains(Object o) {
return ConcurrentHashMap.this.containsValue(o);
}
public void clear() {
ConcurrentHashMap.this.clear();
}
}
final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
public Iterator<Map.Entry<K, V>> iterator() {
return new EntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
V v = ConcurrentHashMap.this.get(e.getKey());
return v != null && v.equals(e.getValue());
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
return ConcurrentHashMap.this.remove(e.getKey(), e.getValue());
}
public int size() {
return ConcurrentHashMap.this.size();
}
public boolean isEmpty() {
return ConcurrentHashMap.this.isEmpty();
}
public void clear() {
ConcurrentHashMap.this.clear();
}
}
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
// force all segments for serialization compatibility
for (int k = 0; k < segments.length; ++k)
ensureSegment(k);
s.defaultWriteObject();
final Segment<K, V>[] segments = this.segments;
for (int k = 0; k < segments.length; ++k) {
Segment<K, V> seg = segmentAt(segments, k);
seg.lock();
try {
HashEntry<K, V>[] tab = seg.table;
for (int i = 0; i < tab.length; ++i) {
HashEntry<K, V> e;
for (e = entryAt(tab, i); e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
} finally {
seg.unlock();
}
}
s.writeObject(null);
s.writeObject(null);
}
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Don't call defaultReadObject()
ObjectInputStream.GetField oisFields = s.readFields();
final Segment<K, V>[] oisSegments = (Segment<K, V>[]) oisFields.get("segments", null);
final int ssize = oisSegments.length;
if (ssize < 1 || ssize > MAX_SEGMENTS
|| (ssize & (ssize - 1)) != 0) // ssize not power of two
throw new java.io.InvalidObjectException("Bad number of segments:"
+ ssize);
int sshift = 0, ssizeTmp = ssize;
while (ssizeTmp > 1) {
++sshift;
ssizeTmp >>>= 1;
}
UNSAFE.putIntVolatile(this, SEGSHIFT_OFFSET, 32 - sshift);
UNSAFE.putIntVolatile(this, SEGMASK_OFFSET, ssize - 1);
UNSAFE.putObjectVolatile(this, SEGMENTS_OFFSET, oisSegments);
// set hashMask
UNSAFE.putIntVolatile(this, HASHSEED_OFFSET, randomHashSeed(this));
// Re-initialize segments to be minimally sized, and let grow.
int cap = MIN_SEGMENT_TABLE_CAPACITY;
final Segment<K, V>[] segments = this.segments;
for (int k = 0; k < segments.length; ++k) {
Segment<K, V> seg = segments[k];
if (seg != null) {
seg.threshold = (int) (cap * seg.loadFactor);
seg.table = (HashEntry<K, V>[]) new HashEntry[cap];
}
}
// Read the keys and values, and put the mappings in the table
for (; ; ) {
K key = (K) s.readObject();
V value = (V) s.readObject();
if (key == null)
break;
put(key, value);
}
}
// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long SBASE;
private static final int SSHIFT;
private static final long TBASE;
private static final int TSHIFT;
private static final long HASHSEED_OFFSET;
private static final long SEGSHIFT_OFFSET;
private static final long SEGMASK_OFFSET;
private static final long SEGMENTS_OFFSET;
static {
int ss, ts;
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class tc = HashEntry[].class;
Class sc = Segment[].class;
// 计算出HashEntry[]&Segment[]的第一个元素的偏移地址
TBASE = UNSAFE.arrayBaseOffset(tc);
SBASE = UNSAFE.arrayBaseOffset(sc);
// 计算出HashEntry[]&Segment[]中每个元素的大小
ts = UNSAFE.arrayIndexScale(tc);
ss = UNSAFE.arrayIndexScale(sc);
HASHSEED_OFFSET = UNSAFE.objectFieldOffset(
ConcurrentHashMap.class.getDeclaredField("hashSeed"));
SEGSHIFT_OFFSET = UNSAFE.objectFieldOffset(
ConcurrentHashMap.class.getDeclaredField("segmentShift"));
SEGMASK_OFFSET = UNSAFE.objectFieldOffset(
ConcurrentHashMap.class.getDeclaredField("segmentMask"));
SEGMENTS_OFFSET = UNSAFE.objectFieldOffset(
ConcurrentHashMap.class.getDeclaredField("segments"));
} catch (Exception e) {
throw new Error(e);
}
// 校验两个数组元素占用内存大小是否是2^n。
if ((ss & (ss - 1)) != 0 || (ts & (ts - 1)) != 0)
throw new Error("data type scale not a power of two");
// 计算位运算时的偏移量
SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);
TSHIFT = 31 - Integer.numberOfLeadingZeros(ts);
}
}ConcurrentHashMap.put(K key, V value) & Segment.put(K key, int hash, V value, boolean onlyIfAbsent)
ConcurrentHashMap.put(K key, V value) 方法：
- 通过 (hash >>> segmentShift) & segmentMask 计算数据要存储在哪个 Segment 上。
- 如果数据要存储的 Segment 在 Segment[] 中还不存在，就需要重新创建，且需要从Segment[0]处获取构建 HashEntry[] 的参数信息。
- 通过 UNSAFE.getObjectVolatile(ss, u) 多次进行 recheck，并在最后通过CAS进行赋值，从而安全的将Segment添加到Segment[]上。
- 数据添加逻辑最终由Segment代理，Segment的数据结构就类似于HashMap。
- put 操作时，Key/Value 都不能为 null。
Segment.put() 执行流程：
- 尝试获取锁 (保证添加操作的线程安全性)。
- 定位到HashEntry[i]中的位置，并获取头节点。
- 遍历HashEntry[index]处的链表，并判断是否有与key匹配的节点。
- 匹配到节点，则更新数据。
- 没有匹配到节点，则将当前的Key、Value包装成一个HashEntry节点，并将HashEntry[i]头节点赋值给新增节点的next字段(即新增节点头插)。
- HashEntry节点创建后，判断新增后的HashEntry[]是否需要扩容，如果需要扩容，则扩容并迁移完数据后在利用头插法将第5步创建的节点添加到对应的HashEntry[]中。
- 如果第6步不需要扩容，则直接将第5步创建的节点头擦到对应的HashEntry[]中。
- 释放锁。
完整的put操作流程图：
Segment.scanAndLockForPut(K key, int hash, V value)
主要作用： 自旋获取锁，同时做一些数据预热优化 (读取数据后将数据添加进CPU高速缓存，加快下次访问速度)。
scanAndLockForPut 方法执行流程：
- 如果首次获取锁成功，则返回node=null，即跟Segment.put() 时的操作保持一致。
- 当首次获取锁失败后进入自旋状态，在自旋过程中创建 HashEntry 节点。创建HashEntry 节点分两种场景：
- 如果key对应HashEntry[i]的头节点为空，则直接创建HashEntry 节点 ( next=null，没有与其它节点关联)。
- 如果key对应HashEntry[i]的头节点不为空，则从头节点开始遍历链表，并在链表遍历结束后创建HashEntry 节点。此处虽然遍历了链表，但即使匹配到了节点也没有保存，目的仅是为了让数据进入CPU高速缓存，在下次使用时能快速命中。
- 当第2步完成后，自旋获取锁的操作才会开始对尝试获取锁的次数进行限制，一旦操作了次数就会强制加锁阻塞当前线程(自旋会依赖CPU)。
- 在自旋过程中，如果头节点发生了改变，就会重新回到第2步。
为什么scanAndLockForPut中要遍历一次链表？
- scanAndLockForPut 使用有限次数的自旋来优化加锁。因为自旋需要依靠CPU，长时间的自旋对CPU的消耗很大，所以直接上锁释放CPU。
- 遍历一次链表也是一种优化方法，主要是尽可能使当前链表中的节点进入CPU高速缓存，提高缓存命中率，以便获取锁定后的遍历速度更快。实际上加锁后并没有使用已经找到的节点，因为它们必须在获取锁后重新获取，以确保更新顺序的一致性，但是遍历一次后通常可以更快地重新定位。这是一种预热优化的方式，scanAndLock中也使用了该优化方式。
Segment.rehash(HashEntry<K,V> node)
作用： 扩容+数据迁移
- 数据扩容：Segment 中HashEntry[] 容量扩容为原先的2倍。
- 参数中的Node添加逻辑：在完成数据迁移后，新增的Node使用头插法插入newTable中。
- 数据迁移方案：
- 常规迁移：因为newTable与oldTable的容量大小是不同的，所以在计算 int index = hash & sizeMask 时，插入table的位置不一定相同，此时常规的数据迁移方式是遍历 oldTable[i] 中每个元素，重新计算其 index 的值后再插入，但是这样就需要对所有数据重新进行计算。
- 优化后的迁移：
- 当 oldTable[i] 处只有一个数据时，直接通过 int index = hash & sizeMask 对位置信息进行重定向。
- 假设 oldTable[i] 处链表的所有数据都重定向到 newTable[n] (即newTable中的同一个)，则只需要将 oldTable[i] 处的头节点添加到 newTable[n] 处即可完成整个链表的复制。
- 假设 oldTable[i] 处链表的所有数据存在 newTable[] 不同的位置，则先将最后一个数据保存到 newTable[] 中，随后重新遍历 oldTable[i] 处链表的所有数据，按照常规迁移的方案进行迁移。
ConcurrentHashMap.get(Object key)
说明： 需要进行两次 hash 计算来定位数据存储的位置。
get 方法的取值流程：
- 先通过 hash 对 Segment 定位。
- 再通过 hash 对 Segment 中的 HashEntry[] 定位，找到头节点。
- 从头节点开始遍历，尝试匹配对应的key。
get 没有加锁的话，ConcurrentHashMap是如何保证读到的数据不是脏数据的呢？
通过 UNSAFE.getObjectVolatile() 直接操作内存获取数据，且 getObjectVolatile() 保证可见性
ConcurrentHashMap.size()
size 获取流程：
- 遍历所有的Segment。
- 把Segment的元素数量累加起来。
- 把Segment的修改次数累加起来。
- 判断所有Segment的总修改次数是否大于上一次的总修改次数。如果大于，说明统计过程中有修改，重新统计，尝试次数+1。如果不是，说明没有修改，统计结束。
- 如果尝试次数超过阈值，则对每一个Segment加锁，再重新统计。
- 再次判断所有Segment的总修改次数是否大于上一次的总修改次数。由于已经加锁，次数一定和上次相等。
- 释放锁，统计结束。
ConcurrentHashMap总结
- JDK1.7的HashMap使用数组+链表的实现方案，但是在并发场景下有安全性问题，为此JDK1.7的ConcurrentHashMap通过引入分段锁Segment来进行优化。
- Segment.scanAndLockForPut 方法内部遍历数据，将数据读入CPU高速缓存，方便下次获取时加快访问速度。
- size的计算： 需要遍历Segment数组并对每个Segment中的个数求和。在极端情况下会对所有的Segment上锁再重新计算个数。
- 头插法： 数据插入时采用头插法。
- 不足
- JDK1.7的ConcurrentHashMap在put、get操作时，都需要进行两次hash计算才能定位到具体的位置。
- JDK1.7的ConcurrentHashMap的Segment[]在构造函数阶段就已经初始化完，且后面无法再扩容Segment[]。在某些场景下锁的粒度可能还是偏大，会影响到存取效率。
ConcurrentHashMap源码分析（JDK 1.8版）
ConcurrentHashMap是基于数组+链表/红黑树的数据结构，添加、删除、更新都是先通过计算key的hash值确定数据的索引值，这和HashMap是类似的，只不过ConcurrentHashMap针对并发做了更多的处理。
ConcurrentHashMap 的构造方法
在 ConcurrentHashMap 中一共有5个构造方法，都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理，数组初始化是在第一次添加元素时完成。
/**
* 默认的构造方法为空，不做任何操作，数组长度默认是16
*/
public ConcurrentHashMap() {
}
/**
* 传递初始化容量的构造方法，传递进来一个初始容量，
* ConcurrentHashMap会基于这个值计算一个比这个值大的2的幂次方数作为初始容量
* 与其他版本不同，例如：传递 16 作为参数，它会计算得到 32 作为初始化容量，而不是 16
*/
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}sizeCtl 含义解析
这个变量是一个非常重要的变量，而且具有非常丰富的含义，它的值不同，对应的含义也不一样。
- sizeCtl为0，代表数组未初始化， 且数组的初始容量为16
- sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值
- sizeCtl为-1，表示数组正在进行初始化
- sizeCtl小于0，并且不是-1，表示数组正在扩容， -(1+n)，表示此时有n个线程正在共同完成数组的扩容操作
put() 方法
/**
* put() 方法会默认调用 putVal() 方法做具体添加元素逻辑
*/
public V put(K key, V value) {
return putVal(key, value, false);
}
/**
* putVal() 方法做具体添加元素逻辑。根据不同的条件进行不同的插入方案选择。
* 大致分为 直接cas插入，链表插入，树插入以及协助扩容等操作。
* 添加完毕后需要对数组元素个数更新，并且判别是否需要扩容。
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 不接受 null 值，直接抛出空指针异常
if (key == null || value == null) throw new NullPointerException();
// 计算 key 的 hash 值
int hash = spread(key.hashCode());
// 记录某个桶上元素的个数，如果超过8个，会转成红黑树
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 1.如果数组为空，表示未进行初始化，需要首先进行初始化操作
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 2.如果 hash 计算得到的桶位置没有元素，利用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
}
// 3.如果hash计算得到的桶位置元素的hash值为MOVED，证明其他线程正在扩容，那么需要协助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 4.hash 计算的桶位置元素不为空，且当前没有处于扩容操作，进行元素添加
else {
V oldVal = null;
// 对当前桶进行加锁，保证线程安全，执行元素添加操作
// 普通链表 ： 尾插法
// 树化后 ： 插入树节点
// 加锁 为节点头元素添加重量级锁
synchronized (f) {
// dcl double check 如果其他线程已经修改头节点，则可以感知
if (tabAt(tab, i) == f) {
// 普通链表节点
if (fh >= 0) {
binCount = 1;
// 遍历链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 找到相同元素，赋值并跳出循环
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, 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，将链表转成红黑树（这个8设计到泊松分布）
if (binCount >= TREEIFY_THRESHOLD)
// 树化，因为树化还有满足数组长度是否超过 64
treeifyBin(tab, i);
// 如果是重复键，直接将旧值返回
if (oldVal != null)
return oldVal;
break;
}
}
}
// 添加的是新元素，维护集合长度，并判断是否要进行扩容操作
addCount(1L, binCount);
return null;
}
/**
* initTable()方法采用 CAS+自旋的方式线程安全的初始化数组
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// cas+自旋，保证线程安全，对数组进行初始化操作
while ((tab = table) == null || tab.length == 0) {
// 说明其他线程正在进行初始化，本线程让出 CPU
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// cas修改sizeCtl的值为-1，修改成功，进行数组初始化，失败，继续自旋
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// double check
if ((tab = table) == null || tab.length == 0) {
// sizeCtl为0，取默认长度16，否则取用户指定的sizeCtl值
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 基于初始长度，构建数组对象
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;
}通过以上源码，我们可以看到，当需要添加元素时，会针对当前元素所对应的桶位进行加锁操作，这样一方面保证元素添加时，多线程的安全，同时对某个桶位加锁不会影响其他桶位的操作，进一步提升多线程的并发效率。
链表树化
/**
* treeifyBin()方法。首先对数组长度判别，查看是否直接扩容数组即可。
* 之后若满足树化条件，则进行树化的步骤，进行双向链表构建，并进行 TreeBin 对象的构建。
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
// 判别当前数组长度是否超过 64（树化阈值），如果不超过阈值则进行数组的扩容
// static final int MIN_TREEIFY_CAPACITY = 64;
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
// 再次核实当前桶存在元素，并且是链表
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 并发安全的进行树化
synchronized (b) {
// double check
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;
}
// 将树化后的 TreeBin 对象插入到桶中。具体的树化逻辑与HashMap不同，将TreeNode封装到 TreeBin 对象中，方便平衡树的过程中保证桶中的对象不发生变化。便于对first元素进行加锁操作
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
/**
* TreeBin 的构造方法为具体构建红黑树的逻辑。
*/
TreeBin(TreeNode<K,V> b) {
super(TREEBIN, null, null, null);
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;
// 构建红黑树的root节点
if (r == null) {
x.parent = null;
x.red = false;
r = x;
}
// 构建红黑树具体逻辑
else {
// 获取元素的 key 和 hash
K k = x.key;
int h = x.hash;
Class<?> kc = null;
// 遍历红黑树
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;
// 根据是否实现 comparable 接口的逻辑判别左右遍历
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
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);
}计数操作
jdk1.8中使用了一个仿造LongAdder实现的计数器，让计数操作额外使用别的基于分段并发思想的实现的类。
/**
* addCount() 方法主要包括两个功能：
* 1.记录ConcurrentHashMap元素数量，会调用fullAddCount具体执行
* 2.扩容ConcurrentHashMap ，会调用transer方法具体执行扩容
*/
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 当CounterCell数组不为空，则优先利用数组中的CounterCell记录数量
// 或者当baseCount的累加操作失败，会利用数组中的CounterCell记录数量
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
// 标识是否有多线程竞争
boolean uncontended = true;
// 当as数组为空
// 或者当as长度小于0
// 或者当前线程对应的as数组桶位的元素为空
// 或者当前线程对应的as数组桶位不为空，但是累加失败
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
// 以上任何一种情况成立，都会进入该方法，传入的uncontended是false
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
// 计算元素个数
s = sumCount();
}
// 接着判断是否需要扩容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 当元素个数达到扩容阈值
// 并且数组不为空
// 并且数组长度小于限定的最大值
// 满足以上所有条件，执行扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 这个是一个很大的正数
int rs = resizeStamp(n);
// sc小于0，说明有线程正在扩容，那么会协助扩容
if (sc < 0) {
// 扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 扩容线程加1，成功后，进行协助扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
// 协助扩容，newTable不为null
transfer(tab, nt);
}
// 没有其他线程在进行扩容，达到扩容阈值后，给sizeCtl赋了一个很大的负数
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 扩容，newTable为null
transfer(tab, null);
s = sumCount();
}
}
}
/**
* fullAddCount() 方法用于将需要添加的个数累加到baseCount上，
* 或者累加到其他CountCell数组中的每个对象中的value属性上
*/
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
// 获取当前线程的hash值，如果为 0，则重新进行 hash 值计算
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
// 数组不为空，优先对数组中CouterCell的value累加
if ((as = counterCells) != null && (n = as.length) > 0) {
// 线程对应的桶为 null
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
// 创建CounterCell对象
CounterCell r = new CounterCell(x); // Optimistic create
// 利用CAS修改cellBusy状态为1，成功则将创建的CounterCell对象放入数组中
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
// double check
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
// 表示放入成功
created = true;
}
} finally {
// 重置标志位
cellsBusy = 0;
}
// 成功退出循环
if (created)
break
// 桶已经被别的线程放置了 CounterCell 对象，继续循环
continue; // Slot is now non-empty
}
}
collide = false;
}
// 桶不为空，重新计算线程hash值，然后继续循环
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
// 重新计算了hash值后，对应的桶位依然不为空，对value累加
// 成功则结束循环
// 失败则继续下面判断
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// 数组被别的线程改变了，或者数组长度超过了可用cpu大小，重新计算线程hash值，否则继续下一个判断
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
// 当没有冲突，修改为有冲突，并重新计算线程hash，继续循环
else if (!collide)
collide = true;
// 如果CounterCell的数组长度没有超过cpu核数，对数组进行两倍扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
// double check
if (counterCells == as) {// Expand table unless stale
// 对 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; // Retry with expanded table
}
// 重新计算 hash 值
h = ThreadLocalRandom.advanceProbe(h);
}
// CounterCell数组为空，并且没有线程在创建数组，修改标记，并创建数组
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
// double check
if (counterCells == as) {
// 初始化容量为2的数组
CounterCell[] rs = new CounterCell[2];
// 放入 count 计数
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
// 数组为空，并且有别的线程在创建数组，那么尝试对baseCount做累加，成功就退出循环，失败就继续循环
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
/**
* sumCount() 方法会聚合所有累加单元和baseCount的值
*/
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
// 获取baseCount的值
long sum = baseCount;
if (as != null) {
// 遍历CounterCell数组，累加每一个CounterCell的value值
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}扩容操作
多线程协助扩容的操作会在两个地方被触发：
① 当添加元素时，发现添加的元素对用的桶位为fwd节点，就会先去协助扩容，然后再添加元素。
② 当添加完元素后，判断当前元素个数达到了扩容阈值，此时发现sizeCtl的值小于0，并且新数组不为空，这个时候，会去协助扩容。
/**
* ConcurrentHashMap触发扩容的时机与HashMap类似，
* 要么是在将链表转换成红黑树时判断table数组的长度是否小于阈值（64），
* 如果小于就进行扩容而不是树化，要么就是在添加元素的时候，
* 判断当前Entry数量是否超过阈值，如果超过就进行扩容。
*/
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
// 如果是扩容线程，此时新数组为null
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 两倍扩容创建新数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 记录线程开始迁移的桶位，从后往前迁移
transferIndex = n;
}
// 记录新数组的长度
int nextn = nextTab.length;
// 已迁移的桶，会用这个对象节点占位（这个节点的hash值为-1--MOVED）
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
// i记录当前正在迁移桶位的索引值
// bound记录下一次任务迁移的开始桶位
// --i >= bound 成立表示当前线程分配的迁移任务还没有完成
if (--i >= bound || finishing)
advance = false;
// 没有元素需要迁移 后续会去将扩容线程数减1，并判断扩容是否完成
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 计算下一次任务迁移的开始桶位置，并将这个值赋值给transferIndex
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 如果没有更多的需要迁移的桶位，就进入该if
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 扩容结束后，保存新数组，并重新计算扩容阈值，赋值给sizeCtl
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 扩容任务线程数减1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 判断当前所有扩容任务线程是否都执行完成
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 所有扩容线程都执行完，标识结束
finishing = advance = true;
i = n; // recheck before commit
}
}
// 当前迁移的桶位没有元素，直接在该位置添加一个fwd节点
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 当前节点已经被迁移
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
// 当前节点需要迁移，加锁迁移，保证多线程安全
// 此处迁移逻辑和jdk7的ConcurrentHashMap相同，不再赘述
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
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;
}
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);
}
setTabAt(nextTab, i, ln);
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;
}
}
}
}
}
}
/**
* helpTransfer() 方法是用于其他线程协助扩容的功能。
*/
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 当数组不为空并且fwd为占位对象并且扩容的新数组存在时，需要进行协助扩容
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
// CAS+自旋
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 扩容线程加1，成功后，进行协助扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 扩容，传递一个不是null的nextTab
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}get方法
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());
// 判断 tab 不为空并且 tab对应的下标不为空
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;
}
// eh < 0 表示遇到扩容
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 遍历链表，直到遍历key相等的值
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}- 调用spread获取hash值，通过(n - 1) & h取余获取数组下标的数据。
- 首节点符合就返回数据。
-
eh<0表示遇到了扩容，会调用正在扩容节点ForwardingNode的find方法，查找该节点，匹配就返回。 -
遍历链表，匹配到数据就返回。 -
以上都不符合，返回null。
get如何实现线程安全
get方法里面没有使用到锁，那是如何实现线程安全。主要使用到了volatile。
一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为可见性。
cpu运行速度比内存速度快很多，为了均衡和内存之间的速度差异，增加了cpu缓存,如果在cpu缓存中存在cpu需要数据，说明命中了cpu缓存，就不经过访问内存。如果不存在，则要先把内存的数据载入到cpu缓存中再返回给cpu处理器。
在多核cpu的服务器中，每个cpu都有自己的缓存，cpu之间的缓存是不共享的。当多个线程在不同的cpu上执行时，比如下图中，线程A操作的是cpu-1上的缓存，线程B操作的是cpu-2上的缓存，这个时候，线程A对变量V的操作对于线程B是不可见的。
但是一个变量被volatile声明，它的意思是：告诉编译器，对这个变量的读写，不能使用cpu缓存，必须从内存中读取或者写入。
上面的变量V被volatile声明，线程A在cup-1中修改了数据，会直接写到内存中，不会写入到cpu缓存中。而线程B无法从cpu缓存读取变量，需要从主内存拉取数据。
综上所述：
-
使用volatile关键字的变量会将修改的变量强制写入内存中。 -
其他线程读取变量时，会直接从内存中读取变量。
volatile在get应用
1）table哈希表：
transient volatile Node<K,V>[] table;使用volatile声明数组，表示引用地址是volatile而不是数组元素是volatile。
2）Node节点
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
}其中val和next都用了volatile修饰，在多线程环境下，线程A修改节点val或者新增节点对别人线程是可见的。所以get方法使用无锁操作是可以保证线程安全。
既然volatile修饰数组对get操作没有效果，那加在volatile上有什么目的呢？
是为了数组在扩容的时候对其他线程具有可见性。
- Node节点的val和next都用volatile修饰，保证线程修改或者新增节点对别人线程是可见的。
-
volatile修饰table数组，保证数组在扩容时其它线程是具有可见性的。
ConcurrentHashMap总结
get方法获取数据，先计算hash值再和数组长度取余操作获取索引位置：
- 通过volatile关键字找到table保证多线程环境下，数组扩容具有可见性,而Node节点中val和next指针都使用volatile修饰保证数据修改后别的线程是可见的。这就保证了ConcurrentHashMap的线程安全性。
-
如果遇到数组扩容，就参与到扩容中。 -
首节点值匹配到数据就直接返回数据，否则就遍历链表或者红黑树，直到匹配到数据。
put方法添加或者更新数据：
- 如果key或value为空，就报错。这是因为在调用get方法获取数据为null,无法判断是获取的数据为null，还是对应的key就不存在映射,HashMap可以通过contains(key)判断，而ConcurrentHashMap在多线程环境下调用contains和get方法的时候，map可能就不同了。
- 如果table数组为空，先初始化数组，先通过sizeCtl控制并发，如果小于0表示有别的线程正在初始化数组，就让出CPU,否则使用CAS将sizeCtl设置成-1。
- 初始化数组之后，如果节点为空，使用CAS添加节点。
- 不为空，就锁住该节点，进行添加或者更新操作。
transfer扩容：
- 在新增一个节点时，链表个数达到阈值8，会将链表转成红黑树，在转成之前，会先判断数组长度小于64,会触发扩容。还有集合个数达到阈值时也会触发扩容。
-
扩容数组的长度是原来数组的两倍。 -
为了支持多线程扩容创建ForwardingNode节点作为标记位，如果遍历到该节点，说明已经做过处理。 -
遍历赋值原来的数据给新的数组。
|
参考： |
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 使用C#创建一个MCP客户端
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现