JDK1.6的ConcurrentHashMap

1、构造函数：

在构造函数中，主要就是根据ConcurrentHashMap的loadfactor、initialCapacity和concurrencyLevel来初始化这个ConcurrentHashMap。下面分别来介绍这几个参数的意义。

if (c++ > threshold) // ensure capacityrehash();

loadfactor是ConcurrentHashMap.Segment的负载因子。当Segment中元素的数目达到了threshold，就会调用rehash来扩容。Segment中的threshold的大小=Segment中表的大小*loadfactor。loadfactor的默认大小是0.75，代表当元素数目达到表的3/4的时候就会对这个Segment进行扩容。

if (concurrencyLevel > MAX_SEGMENTS)concurrencyLevel = MAX_SEGMENTS;// Find power-of-two sizes best matching argumentsint sshift = 0;int ssize = 1;while (ssize < concurrencyLevel) {++sshift;ssize <<= 1;}segmentShift = 32 - sshift;segmentMask = ssize - 1;this.segments = Segment.newArray(ssize);

concurrencyLevel是代表这个ConcurrentHashMap支持并发的等级，也就是有多少个Segment。concurrencyLevel的大小总是2的指数次方，并且不会超过1<<16。

if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;int c = initialCapacity / ssize;if (c * ssize < initialCapacity)++c;int cap = 1;while (cap < c)cap <<= 1;for (int i = 0; i < this.segments.length; ++i)this.segments[i] = new Segment<K,V>(cap, loadFactor);

initialCapacity是代表当前ConcurrentHashMap中的初始大小，并不是每个Segment的大小，initialCapacity不超过1<<30。注意代码中的cap，Segment的大小永远都是2的整数次幂大小，这样能使元素更加平均的分布到segments中。

2、Segment

Segment是一种分片锁的思想，在介绍ConcurrentHashMap的其他方法之前要先知道Segment的一些属性的作用。

transient volatile int count; //<span style="font-size:12px;">Segment中的元素数目</span>。transient int modCount; //Segment中修改元素的次数。transient int threshold; //扩容Segment的阈值。transient volatile HashEntry<K,V>[] table; //Segment储存元素的地方。final float loadFactor; //负载因子。

modCount调用的地方有put、remove、clear。replace则不会调用modCount，因为它没有Segment的表的物理结构。

final Segment<K,V> segmentFor(int hash) {return segments[(hash >>> segmentShift) & segmentMask];}

根据hash的高位来将该键值对放在不同的Segment。

3、put

put方法有两个版本，put和putIfAbsent。这两个方法的区别就是当key在ConcurrentHashMap已经存在的时候是否替换value。

V put(K key, int hash, V value, boolean onlyIfAbsent) {lock();try {int c = count;if (c++ > threshold) // ensure capacityrehash();HashEntry<K,V>[] tab = table;int index = hash & (tab.length - 1);HashEntry<K,V> first = tab[index];HashEntry<K,V> e = first;while (e != null && (e.hash != hash || !key.equals(e.key)))e = e.next;V oldValue;if (e != null) {oldValue = e.value;if (!onlyIfAbsent)e.value = value;}else {oldValue = null;++modCount;tab[index] = new HashEntry<K,V>(key, hash, first, value);count = c; // write-volatile}return oldValue;} finally {unlock();}}

在对表进行修改之前，会先加锁。然后判断是否需要对表扩容。接下来根据hash值计算地址取链表头。遍历链表，寻找Key是否已经在表里存在了，如果没有存在则直接从链表头插入，如果已经存在则要根据onlyIfAbsent来判断是否需要替换oldValue。返回oldValue，解锁。

4、rehash

rehash这个的访问权限是default的，所以只有子类和同包的类才可以调用它。在ConcurrentHashMap中发现只有Segment的put方法才调用了rehash，所以在rehash中并不需要加锁来防止出现并发问题。

void rehash() {HashEntry<K,V>[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity >= MAXIMUM_CAPACITY)return;HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);threshold = (int)(newTable.length * loadFactor);int sizeMask = newTable.length - 1;for (int i = 0; i < oldCapacity ; i++) {// We need to guarantee that any existing reads of old Map can//  proceed. So we cannot yet null out each bin.HashEntry<K,V> e = oldTable[i];if (e != null) {HashEntry<K,V> next = e.next;int idx = e.hash & sizeMask;//  Single node on listif (next == null)newTable[idx] = e;else {// Reuse trailing consecutive sequence at same slotHashEntry<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 all remaining nodesfor (HashEntry<K,V> p = e; p != lastRun; p = p.next) {int k = p.hash & sizeMask;HashEntry<K,V> n = newTable[k];newTable[k] = new HashEntry<K,V>(p.key, p.hash,n, p.value);}}}}table = newTable;}

获得Segment表的大小oldTable.length，然后乘2判断是否超过1<<30。如果大于直接返回。否则会使用oldTable.length<<1创建新的数组，并且计算新的threshold。接下来遍历oldTable把每个链表中的Entry重新插入到Segment中。因为Segment的大小是2的整数次幂，所以原来位置链表中的Entry只有两个选择，一个是插入在原位curIdx的链表中，一个是插入到oldTable.length+curIdx的链表中。源码中的处理方式，获得i位置上的链表头。如果非空，则判断next是否为空，如果next非空直接插入到对应位置做为链表头。如果next不为空，则需要先遍历一次链表，寻找最后一个idx不同的Entry。这里的优化措施就是第一次遍历链表记录下lastRun，lastRun后面的Entry的idx都和lastRun的idx相同，所以不需要多次插入，只需把lastRun及lastRun后面的节点一次插入到新链表的头后，然后开始重新遍历链表，将剩余的表中Entry插入到链表头中去。

5、get

get也会交给相应的Segment中去操作。但是get不会对表的结构产生改变，所以不用加锁。但是如果不加锁的话会产生一致性的问题，put到Segment中的Entry，如果并发读可能会访问不到相应的Entry。所以ConcurrentHashMap中的get是弱一致性的(具体方法大家可以参考http://ifeve.com/concurrenthashmap-weakly-consistent/)。

V get(Object key, int hash) {if (count != 0) { // read-volatileHashEntry<K,V> e = getFirst(hash);while (e != null) {if (e.hash == hash && key.equals(e.key)) {V v = e.value;if (v != null)return v;return readValueUnderLock(e); // recheck}e = e.next;}}return null;}

这里的count != 0的注释和put方法中的count=c的注释就解释了这两个操作是hb的，但是无法保证操作的原子性，所以没办法达到强一致性。

6、contain、containsValue

contain就是调用了containValue，下面上containsValue的源码。

public boolean containsValue(Object value) {if (value == null)throw new NullPointerException();// See explanation of modCount use abovefinal Segment<K,V>[] segments = this.segments;int[] mc = new int[segments.length];// Try a few times without lockingfor (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {int sum = 0;int mcsum = 0;for (int i = 0; i < segments.length; ++i) {int c = segments[i].count;mcsum += mc[i] = segments[i].modCount;if (segments[i].containsValue(value))return true;}boolean cleanSweep = true;if (mcsum != 0) {for (int i = 0; i < segments.length; ++i) {int c = segments[i].count;if (mc[i] != segments[i].modCount) {cleanSweep = false;break;}}}if (cleanSweep)return false;}// Resort to locking all segmentsfor (int i = 0; i < segments.length; ++i)segments[i].lock();boolean found = false;try {for (int i = 0; i < segments.length; ++i) {if (segments[i].containsValue(value)) {found = true;break;}}} finally {for (int i = 0; i < segments.length; ++i)segments[i].unlock();}return found;}

判断ConcurrentHashMap中是否包含某个value就要在每个Segment去寻找是否包含这个value。首先先创建的mc数组就是记录每个Segment的modCount，然后去执行遍历查找操作，查找成功则会返回true。如果不成功则会再次遍历Segments的modCount去和mc中的每个值去比较，判断是否某个Segment发生了改变。如果发生了改变，cleanSweep被设置为false，则会重新进行。直到每个Segment在这期间都没有被修改过，然后会返回false。int c = segments[i].modCount;保证了可见性。如果每次都发现segments的Entry被修改过，那么重试次数达到RETRIES_BEFORE_LOCK的时候就会继续跳过无锁化的查找，对每个Segment进行加锁，然后再进行查找。

7、isEmpty

public boolean isEmpty() {final Segment<K,V>[] segments = this.segments;int[] mc = new int[segments.length];int mcsum = 0;for (int i = 0; i < segments.length; ++i) {if (segments[i].count != 0)return false;elsemcsum += mc[i] = segments[i].modCount;}if (mcsum != 0) {for (int i = 0; i < segments.length; ++i) {if (segments[i].count != 0 ||mc[i] != segments[i].modCount)return false;}}return true;}

在isEmpty中还是使用了记录segments的modCount的方式来进行统计，第一遍统计，如果有某个Segment的count不为0则直接返回false，如果统计segments的count都为0，那么需要第二次遍历segments，如果遍历的时候某个Segment的count不为0则直接返回false。如果某个Segment的count为0，并且modCount不为0，说明发生了ABA问题，那么就返回false，因为在isEmpty统计的过程中，segments并不为空。

转载请标明出处：http://blog.csdn.net/hahaha1232