概述
HashMap是线程不安全的map, ConcurrentHashMap 是线程安全的map,并能适应高并发的场景。
核心属性和数据结构
final int segmentMask;
final int segmentShift;
key生成的hash值 位移segmentShift 并与上segmentMask 就是 这个key的Segment在segments数组中的索引位置。
final Segment<K,V>[] segments;//存储数据的segment数组
ConcurrentHashMap数据由segment数组存储,每个segment都是哈希表的结构。多线程下,命中同一个Segment才会 锁排队,这样设计减少了锁竞争的几率。
源码分析
构造方法分析
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
// 默认 initialCapacity ==16,loadFactor==0.75,concurrencyLevel==16
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;// 最终 Segment数组长度
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;//获取 小于concurrencyLevel的 2倍数的最大值
}//concurrencyLevel的值越大 初始化的Segment数组长度越大
this.segmentShift = 32 - sshift;//sshift==4, segmentShift ==28
this.segmentMask = ssize - 1;//segmentMask ==15
//segmentShift 和segmentMask 用来计算key的Segment在segments数组中的索引位置。
//ConcurrentHashMap中key计算出的hash值是int类型的。 获取segmentShift 和segmentMask是为了 获取 hash的sshift位数值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;//获取ssize的整数倍 initialCapacity==16, ssize==16,c==1
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;//cap ==2
while (cap < c)
cap <<= 1;
// 这样搞下来 cap 是2的N次幂, cap *ssize >=initialCapacity, 不知道为啥这样搞
// create segments and segments[0]
Segment<K,V> s0 = //cap==2
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];//ssize==16
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
默认创建了一个长度为16的Segment数组。并初始化了segments[0]
}
插入节点
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;// 默认 获取hash高4位的值
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck获取 j对应的Segment实例
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);//获取不到,检查并创建一个。
return s.put(key, hash, value, false);
}
ensureSegment
//获取不到,检查并创建一个Segment,并链接到数组k位置
private Segment<K,V> ensureSegment(int k) {
final Segment<K,V>[] ss = this.segments;
long u = (k << SSHIFT) + SBASE; // raw offset
Segment<K,V> seg;
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {//以Volatile方式检查 是否存在
//不存在 创建一个Segment并链接到数组k位置
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);//使用槽位0的节点获取临界值。
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];//创建HashEntry数组
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck 再次检查是否在
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { 三次检查 并处理 CAS失败
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
ConcurrentHashMap 的插入节点 依赖Segment的插入节点方法实现
Segment构造方法
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;//负载因子
this.threshold = threshold;//临界值, 节点数超过这个值要进行扩容
this.table = tab;// 存储节点的HashEntry数组
}
Segment插入节点
//主要是自旋获取锁,期间辅助寻找node位置, 如果找不到则创建node并返回。
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//根据hash获取key所在槽位的第一个HashEntry
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
//重试次数
int retries = -1; // negative while locating node
//尝试获取锁,没有获取到,开始自旋
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
//试着检索key对应的node,没有则创建。可能出现执行到一半,获取到了锁,终止检索。
//如果一直没有获取到锁,由于retries值的控制会一直执行,直到检索出结果
if (e == null) {//code1 涉及到无锁化算法 中的1一个步骤。
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
//重试次数如果超过64次,调用重入锁lock获取锁
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
//重试次数0或超过1一次且头部节点发生了改变, 设置retries,重新检索key对应的node。
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
code1 在实现旋获取锁的基础上,如果找不到key对应节点就创建一个,在自旋期间创建的节点为以后的执行节省了执行时间。
put方法
//在一个Segment 片段里put key-value
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null ://尝试获取锁 ,获取不到就自旋获取
scanAndLockForPut(key, hash, value);
//scanAndLockForPut 主要是自旋获取锁,其次如果找不到则创建node并返回。
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
//根据index获取key所在槽位的第一个HashEntry
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
//所在槽位有HashEntry链表
if (e != null) {
K k;
//找到了key对应的node,修改原来的value
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {// 允许 覆盖旧值
e.value = value;
++modCount;
}
break;//执行完修改 跳出循环 结束调用
}
//没找到继续沿着链表next查找
e = e.next;
}
//所在槽位没有HashEntry链表或槽位的链表中没有key对应的node,在链表头部插入新的节点。
else {
//在 scanAndLockForPut中创建了node,插入链表头部。
//注意:next赋值为first,说明 没有创建的node是插入链表的头部
if (node != null)
node.setNext(first);
else
//创建新的node
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
//节点个数超过阀值,执行rehash
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
//在Segment table上更新对应槽位上的链表
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
entryForHash和entryAt都是获取key所在槽位的第一个HashEntry,entryForHash比entryAt多了一步计算key对应记得所在槽位的index值
Segment.put()方法中如果node 不为null,证明在scanAndLockForPut中已经确定没有找到key对应节点,why在还重新查找一次?
scanAndLockForPut中确定没有找到key对应节点的时候还没有获取锁,其他线程有可能加入同样value的节点,要重新搜索
逻辑总结:
插入的节点时,先尝试加锁,不成功就自旋转获取锁, 然后计算hash值,根据hash定位所在槽位, 槽位上是个链表,从第一个节点开始向后查找。如果key对应的node已经存在, 修改原来的value结束调用,如果不存在创建key-value新节点插入链表头部。
注意 scanAndLockForPut 自旋转期间辅助创建Node, 节省后续的执行时间 是一个亮点。
搞明白ConcurrentHashMap的插入节点逻辑后,查询节点 就比较简单了,下面分析。
查询节点
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所在Segment 内存偏移值
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {//获取Segment节点,并检查是否存在。
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {//获取对应的 HashEntry ,遍历链表查找节点
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;//找到了 返回
}
}
return null;//没找到 返回 null
}
逻辑总结:
获取key对应,Segment节点,并检查是否存在,找到/获取对应的 HashEntry ,遍历链表查找节点,找到了 返回,没找到 返回 null.
总结:ConcurrentHashMap 依赖Segment 数组实现,理解 Segment的插入节点流程 是分析源码的重点。