public ConcurrentHashMap() {
// 默认Table容量为16,默认扩容因子为0.75,默认并发级别为16(即分段锁个数)
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
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数组的大小,一定为2的幂,例如用户设置并发度为17,则实际Segment数组大小则为32
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
/*用于定位元素所在segment。segmentShift表示偏移位数,通过前面的int类型的位的描述我们可以得知,
int类型的数字在变大的过程中,低位总是比高位先填满的,为保证元素在segment级别分布的尽量均匀,
计算元素所在segment时,总是取hash值的高位进行计算。segmentMask作用就是为了利用位运算中取模的操作:
a % (Math.pow(2,n)) 等价于 a&( Math.pow(2,n)-1)*/
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
// 保证每个Segment中tabel数组的大小,一定为2的幂,初始化的三个参数取默认值时,table数组大小为2
while (cap < c)
cap <<= 1;
// 初始化Segment数组,并实际只填充Segment数组的第0个元素。
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
// 定位segment
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// 获取segment,获取成功后接着获取segment对应的tab数组
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
// 定位table,依次扫描这个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 e.value;
}
}
return null;
}
static final class HashEntry<K,V> {
final int hash;
final K key;
// 用volatile关键字修饰,在高并发下的情况下保证取得的元素是最新的
volatile V value;
volatile HashEntry<K,V> next;
}
public V put(K key, V value) {
Segment<K,V> s;
/*ConcurrentMaps不允许key、value为null,这与数据结构是否支持并发息息相关。当ConcurrentMaps使用map.get(key)时返回为null,
无法判断key是不存在还是值为空,non-concurrent还可以再调用map.contains(key)检查,
但ConcurrentMaps可能再两次调用间已经发生改变*/
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
/*首先定位segment,当这个segment在当前所在的ConcurrentMap初始化后,还为null,
由ensureSegment方法负责创建并填充这个segment(填充使用CAS机制)*/
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
// 接上述s.put,即内部类static final class Segment<K,V> extends ReentrantLock的put方法
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 对Segment 加锁
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
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 {
if (node != null)
// 新元素往头节点插入
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
// 如果需要扩容,则重新计算各个节点哈希值
rehash(node);
else
// 新元素挂载到table数组中,在table中拥有相同哈希值的结点就形成了一个以新元素为头节点的链表
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}