ConcurrentHashMap
ConcurrentHashMap 结构
采用了分段锁的方法提高COncurrentHashMap并发，一个map里面有一个Segment数组——即多个Segment，一个Segment有一个HashEntry数组——即多个HashEntry。每个Segment持有一个锁，在put的时候会给Segment上锁，但是get的时候没有锁
初始化
// initialCapacity：map初始化大小
// loadFactor：负载因子，当map中元素个数大于loadFactor*最大容量的时候进行refresh扩容
// concurrencyLevel：并发级别，因为这个类是采用分段锁的机制实现的，该值表示分段数，需要规整为2的n次方——为了按位与计算segment数组的索引
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;
// 有可能传入的concurrencyLevel不是2的n次方，向上规整为2的n次方
while (ssize < concurrencyLevel) {
// sshift记录左移的次数
++sshift;
// 最终的segment个数——也就是并发级别
ssize <<= 1;
}
// 参与定位segment散列
this.segmentShift = 32 - sshift;
// 参与定位segment散列
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// c为每个segment的容量
int c = initialCapacity / ssize;
// 因为是整数除法，如果除不尽会去尾，加上1保证容量大于等于给定的值
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
// 新建一个segment作为segment数组的第一个元素
// 这里没有初始化所有的segment，采用lazy-init的方式按需初始化
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;
}
put操作
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
// 定位segment，因为segment是ssize个，所以定位segment就是用hash值对ssize取模，使用位运算就是
// 将hash右移32-sshift位，因为hash是32位，ssize是sshift位
// 将得到的值和segment与运算，segment是ssize位全1二进制大小
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
// 因为是按需初始化，可能定位到的segment尚未初始化
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 获取锁，如果失败，会进行指定次数的尝试，超过指定次数以后会调用AbstractQueuedSynchronizer的acquire方法再次尝试获取，如果获取不到则阻塞
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
// 与运算得到在hashEntry数组中中的位置
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
// 如果数组中该位置原来有值
K k;
// 如果存在相同的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 {
// 链表查找到最后发现不包含这个key
if (node != null)
// 如果scanAndLockForPut返回的node非空
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
// 如果当前元素数大于threshold阈值则扩容
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
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()) {
// 自旋过程中遍历链表是为了缓存预热，减少hash表经常出现的cache miss
// 原代码注释
// we might as well help warm up the associated code and accesses as well
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
if (e == null) {
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;
}
else if (++retries > MAX_SCAN_RETRIES) {
// 超过次数之后阻塞
lock();
// 获得锁之后跳出循环
break;
}
// 当retries个位是0并且tabel这个位置的头改变了（和之前的first不一致了，说明其他线程修改了）
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
// 如果链表头改变则重新开始查找
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
hash算法
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);
}
get方法
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;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
// 因为Segment的table是votile，所以在读的时候不需要上锁
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;
}
参考
http://nfhy.wang/Java-ConcurrenceHashMap-Segment/
Java并发编程的艺术