在JDK源码学习(1)-HashMap源码分析,HashMap与HashTable的差别的时候我们就学习过HashMap和Hashtable，知道Hashtable是线程安全的，而HashMap在多线程的情况下是不安全的。我们在多线程的情况下除了用Hashtable代替HashMap以外，也可以用collections.synchronizedmap()，还可以使用uitl.concurrent包下提供的ConcurrentHashMap，而且ConcurrentHashMap性能要比Hashtable好很多。
Hashtable与ConcurrentHashMap
这两种方式的主要差别加锁的方式不一样，从而影响执行的效率。
对Hashtable来说，看过源码的都知道Hashtable使用的Synchronized关键字修饰方法的方式来同步，所以加锁的粒度是非常大的。使用Synchronized时，是对整个表对象加锁了，其他线程不能访问表的任何一块区域，只有等待获取对象锁，所以这种方式的等待时间是非常长的。
在ConcurrentHashMap使用另一种加锁方式：ReentrantLock，ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁ReentrantLock。只要多个修改操作发生在不同的段上，它们就可以并发进行。 关于ReentrantLock锁的使用可以查看java locks包下提供的锁。
ConcurrentHashMap有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。这里“按顺序”是很重要的，否则极有可能出现死锁。
源码分析（jdk 1.7）
- 首先来看ConcurrentHashMap主要的数据结构：
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
/**
* Mask value for indexing into segments. The upper bits of a
* key's hash code are used to choose the segment.
*/
final int segmentMask;
/**
* Shift value for indexing within segments.
*/
final int segmentShift;
/**
* The segments, each of which is a specialized hash table.
*/
final Segment<K,V>[] segments;其中的segments数组就是来存储数据的，每个segments都是一个table，这有就把一个大的table分成许多小的table，对每个table的操作都不会发生影响。而segmentShift和segmentMask这两个全局变量在定位segment时的哈希算法里需要。
- segments使用其结构如下：
static final class Segment<K,V> extends ReentrantLock implements Serializable {
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
/**
* The per-segment table. Elements are accessed via
* entryAt/setEntryAt providing volatile semantics.
*/
transient volatile HashEntry<K,V>[] table;
/**
* The number of elements. Accessed only either within locks
* or among other volatile reads that maintain visibility.
*/
transient int count;
/**
* The total number of mutative operations in this segment.
* Even though this may overflows 32 bits, it provides
* sufficient accuracy for stability checks in CHM isEmpty()
* and size() methods. Accessed only either within locks or
* among other volatile reads that maintain visibility.
*/
transient int modCount;
/**
* The table is rehashed when its size exceeds this threshold.
* (The value of this field is always <tt>(int)(capacity *
* loadFactor)</tt>.)
*/
transient int threshold;
/**
* The load factor for the hash table. Even though this value
* is same for all segments, it is replicated to avoid needing
* links to outer object.
* @serial
*/
final float loadFactor;
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}可以看到segments里面的存储结构是HashEntry[] table，这和我们hashMap里Entry类似。所以一个segments就像一个HashMap。
- HashEntry定义如下：
static final class HashEntry<K,V> {
final int hash;
final K key;
volatile V value;
volatile HashEntry<K,V> next;可以看到除了value（volatile修饰多线程下具有可见性，可查volatile如何保证可见性）不是final的，其它值都是final的，这意味着不能从hash链的中间或尾部添加或删除节点，因为这需要修改next引用值，所有的节点的修改只能从头部开始。对于put操作，可以一律添加到Hash链的头部。但是对于remove操作，可能需要从中间删除一个节点，这就需要将要删除节点的前面所有节点整个复制一遍，最后一个节点指向要删除结点的下一个结点。
所以ConcurrentHashMap完全允许多个读操作并发进行，读操作并不需要加锁。如果使用传统的技术，如HashMap中的实现，如果允许可以在hash链的中间添加或删除元素，读操作不加锁将得到不一致的数据。
- 再从ConcurrentHashMap的构造函数看起
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;
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
//第一个参数是段里面的数组长度，第二个参数是效率因子（前面有讲到）,第三个参数是段数组的大小，也就是支持的并发线程数
// 上面可以不用看。这里和hashMap的原理一样获取2的倍数来进行数组长度,ssize=16, sshift=4
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;
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];
//数组的大小设为ssize，默认为16,。也就分成16个小的table。
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}segmentShift和segmentMask这两个全局变量在定位segment时的哈希算法里需要使用，sshift等于ssize从1向左移位的次数，在默认情况下concurrencyLevel等于16，1需要向左移位移动4次，所以sshift等于4。segmentShift用于定位参与hash运算的位数，segmentShift等于32减sshift，所以等于28，这里之所以用32是因为ConcurrentHashMap里的hash()方法输出的最大数是32位的，后面的测试中我们可以看到这点。segmentMask是哈希运算的掩码，等于ssize减1，即15，掩码的二进制各个位的值都是1。
初始化Segment。Segment的构造函数可以看上面代码。输入参数loadFactor是负载因子，(int)(cap * loadFactor)是阀值threshold，new HashEntry[cap]是segments中存储数据结构，也就是一个小块的hashtable。
上面代码中的变量cap就是segment里HashEntry数组的长度，它等于initialCapacity除以ssize的倍数c，如果c大于1，就会取大于等于c的2的N次方值，所以cap不是1，就是2的N次方。segment的容量threshold＝(int)cap*loadFactor，默认情况下initialCapacity等于16，loadfactor等于0.75，通过运算cap等于1，threshold等于零。
- ConcurrentHashMap的写操作
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;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}首先通过key的hash值和segmentShift、segmentMask的位操作确定插入segments数据的位置j，通过索引j获得segments，再向该segments里面插入。segment的插入如下：
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
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
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}首先通过trylock()获取锁，假如put一开始就拿到锁，就执行下面的操作。如果没拿到锁它不是直接进入等待状态，而是调用了scanAndLockForPut()操作，该操作持续查找key对应的节点链中是已存在该机节点，如果没有找到已存在的节点，则预创建一个新节点，并且尝试n次，直到尝试次数操作限制，才真正进入等待状态，计所谓的自旋等待。对最大尝试次数，目前的实现单核次数为1，多核为64：
再获得锁之后，首先通过hash值得到映射值index，然后就是getFirst的过程，确定链表头部的位置。
对链表开始循环，在for循环是在链表中寻找和要put的元素相同key的元素，如果找到，就直接更新更新key的value，如果到链表结尾也没有找到，就生成一个新的HashEntry并且把它加到整个Segment的头部，然后再更新count的值。如果数量超过了threshold就要进行rehash()操作。
- 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;
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 e.value;
}
}
return null;
}可以看到ConcurrentHashMap的get操作是不用加锁的，只需要通过hash运算找到对应的位置就行。
扫一扫
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
