记录阅读Java 7 ConcurrentHashMap源码的过程,阅读前建议先了解ConcurrentHashMap与HashMap异同,以及对ConcurrentHashMap大致结构有个印象。另外还需要了解Unsafe类,Reentrantlock机制。
部分关键成员变量
static final int DEFAULT_INITIAL_CAPACITY = 16;
默认初始化容量,这里说的容量是指总容量,即每个Segment分到的容量之和static final float DEFAULT_LOAD_FACTOR = 0.75f;
默认加载因子,由于Segment是无法扩容的,所以这里针对的是Segment中的tablestatic final int DEFAULT_CONCURRENCY_LEVEL = 16;
直译是默认并发级别,首先需要知道ConcurrentHashMap为了控制并发,采用的是Segment锁,也就是同一时间每个Segment只允许一个线程写入,而且其他线程不能读取。所以,对于n个Segment,也就允许n个线程并发写入。因此这里可以理解为初始Segment数量。static final int MAXIMUM_CAPACITY = 1 << 30;
最大允许容量static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
每个Segment中table的最小容量static final int MAX_SEGMENTS = 1 << 16;
最大Segment容量数
构造方法
先附源码:
//initialCapacity 初始容量,指的是全局容量
//loadFactor 加载因子
//concurrentLevel 并发级别
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;//保证值为2^n
}
//这两个参数之后会用到,先有个印象
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;//计算每个Segment分到的大小
if (c * ssize < initialCapacity)
++c;
//这里默认每个Segment最小table大小为2,这样可以保证至少在第一次插入时不会扩容,第二次插入才进行resize,提升性能
int cap = MIN_SEGMENT_TABLE_CAPACITY;
//这里保证每个Segment中的table大小保持为2^n
while (cap < c)
cap <<= 1;
// create segments and segments[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类方法,由于是native方法,不好查看源码,这里记住这个方法为向ss数组中插入Segment
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
//segments是用final修饰,一旦初始化后,segments的值就无法改变
this.segments = ss;
}
为了方便理解,我们取一组数据分析:
全局容量:initialCapacity=16
加载因子:loadFactor=0.75f
并发级别:concurrencyLevel=16
移位数(中间值):sshift=4
Segment大小:ssize=16
Segment移位数:segmentShift = 32 - sshift=28
Segment掩码:segmentMask = ssize - 1=15
每个Segment平均容量(中间值):c=initialCapacity / ssize=1
每个Segment平均容量:cap = MIN_SEGMENT_TABLE_CAPACITY=2
new Segment<K,V>
:Segment的构造方法也比较好理解,传入加载因子loadFactor
,传入阈值(int) (cap * loadFactor)
,传入存放key-value的table(HashEntry<K,V>[])new HashEntry[cap])
。这里需要先初始化Segment[0] 是有原因的,之后再分析。
put()
public V put(K key, V value) {
Segment<K,V> s;
//与HashMap不同,key和value都不能为空,再调用下面hash(key)方法时,如果key为空也会报空指针异常
if (value == null)
throw new NullPointerException();
//获取key的hash值
int hash = hash(key);
//segmentShift和segmentMask是用来计算Segment数组下标的!
//上面我们取值为28和15,可以代入计算一下,将32位的hash先无符号右移28位,然后将低4位和segmentMask相与得到数组下标
int j = (hash >>> segmentShift) & segmentMask;
//利用Unsafe类getObject方法直接从内存中取出指定偏移量的Segment实例对象
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
//如果实例对象为空,需要先初始化segments[j]
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
对put()方法总体有个认识后,我们来“肢解”里面一些方法:
int hash(Object k)
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下标是通过将hash值与segments数组长度低四位相与得到,试想下,如果有两个hash值,它们的高28位不同,但是低四位相同,那么相与的结果也是相同的,造成了hash冲突,所以ConcurrentHashMap对获取hash的方法进行了封装,在hash()方法进行了一连串的位运算,目的就是令高位的不同会造成hash值低位的变化,这样获取的j
就不同了。
Segment<K,V> ensureSegment(int 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) {
//这里就说明了为什么要先初始化segments[0]
//直接copy segments[0]当前(因为segments[0]可能已经扩容过)的table容量大小、加载因子和阈值来初始化segments[j]
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);
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
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,保证在线程安全状况下写入segments数组
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
这里我简单说一下在这个方法中CAS以及四个参数的作用
- 第一个参数是需要写入的目标对象,这里是segments数组
- 第二个参数指内存偏移量
- 第三个参数是期望的内存值,这里期望是null
- 第四个参数是需要更新的值
大概思路为:第一次从内存中读取到某个值,记为a,内存偏移量记为u;现在需要将新的值,记为b,写入到内存中偏移量为u处,为了避免在我第一次读取,到写入这段时间,其他线程对该内存值进行了修改,所以我将之前记录的值a与此时此刻的内存值进行对比,如果相同,则可以认为没有其他线程修改过,我就可以将新的值b写入到内存中,保证了线程安全。当然,也有可能其他线程曾经修改过,只是修改的值与原值一样,所以我还可以加个版本号来控制,每次修改后版本号+1,这样直接对比版本是否相同就可以确认有没有被修改过。
V put(K key, int hash, V value, boolean onlyIfAbsent)
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//尝试获取锁,如果失败,会进入scanAndLockForPut轮询获取
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
//table数组即是Segment中存放key-value的数组
HashEntry<K,V>[] tab = table;
//利用之前得到的hash,计算存放在table的下标
int index = (tab.length - 1) & hash;
//获取链表第i个节点,既是table[i]
HashEntry<K,V> first = entryAt(tab, index);
//分两种情况:链不为空,遍历链,如果key相同,替换并返回旧值;
//链为空或者已经遍历至末尾,将新的key-value插入到链表头
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 {
//node的值依赖获取锁的操作,之后再介绍这里的逻辑,现在只需要知道这里的if-else操作是将新的key-value设为链表头
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
//判断是否需要扩容,count记录的是当前Segment中table数组已存入值的数量
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//扩容并将node插入到扩容后的table中
rehash(node);
else
setEntryAt(tab, index, node);//将node放入table
++modCount;//与fast-fail机制有关
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
HashEntry<K,V> scanAndLockForPut(K key, int hash, V value)
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//从当前Segment的table中获取指定hash的HashEntry实例
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
//retries控制流程
int retries = -1; // negative while locating node
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
if (e == null) {
//初始化node
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
//如果找到指定的key
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
else if (++retries > MAX_SCAN_RETRIES) {
//如果重试次数已达到上限,执行lock();除非获取到锁,否则当前线程处于阻塞状态
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
//retries为偶数时,重新检查链表,如果由于并发,原位置节点发生改变,重新走一遍流程
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
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);
}
逻辑是这样的:在上面的put方法中,首先尝试获取一次锁,如果获取失败,证明该Segment存在并发,进入到entryForHash方法轮询获取锁,为了提高效率,轮询过程中预先创建node实例。所以,归结起来,scanAndLockForPut方法最主要完成的两件事就是:轮询取锁和创建node实例。
rehash
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1;//扩容一倍,保证容量为二次幂
threshold = (int)(newCapacity * loadFactor);//新的阈值
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;//求取table下标的掩码值
//遍历每个HashEntry,重新计算下标并迁移到扩容后的table
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;
// Clone remaining nodes
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);
}
}
}
}
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
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);
//计算指定的Segment在内存中的偏移值
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
//获取Segment并判断table是否存在
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
//再次利用hash求出table[i]内存偏移值,遍历HashEntry链,查找是否有相同的key
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;
}
get()方法简直不要太简单,思路也非常好理解。
附上涉及到UNSAFE的常量介绍(纯属个人理解,可能会有错误的地方,请斟酌参考)
static {
int ss, ts;
try {
//获取Unsafe实例
UNSAFE = sun.misc.Unsafe.getUnsafe();
//获取一维数组的类对象,对象数组是在运行时由虚拟机自动创建
Class tc = HashEntry[].class;
Class sc = Segment[].class;
//数组类对象在内存的基值(可以理解成操作系统中的段式存储,先找到哪个段,然后再确定段中的偏移量)
TBASE = UNSAFE.arrayBaseOffset(tc);
SBASE = UNSAFE.arrayBaseOffset(sc);
//数组规模,可以理解成数组的大小
ts = UNSAFE.arrayIndexScale(tc);
ss = UNSAFE.arrayIndexScale(sc);
//获取ConcurrentHashMap中字段的偏移值,反射获取的字段对象作为传入参数
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);
}
//保证Segment[]和HashEntry[]数组规模为二次幂
if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0)
throw new Error("data type scale not a power of two");
//基于BASE的偏移量
SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);
TSHIFT = 31 - Integer.numberOfLeadingZeros(ts);
}