ConcurrentHashMap的rehash过程

void rehash() {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity >= MAXIMUM_CAPACITY)
return;

/*
* Reclassify nodes in each list to new Map.  Because we are
* using power-of-two expansion, the elements from each bin
* must either stay at same index, or move with a power of two
* offset. We eliminate unnecessary node creation by catching
* cases where old nodes can be reused because their next
* fields won't change. Statistically, at the default
* threshold, only about one-sixth of them need cloning when
* a table doubles. The nodes they replace will be garbage
* collectable as soon as they are no longer referenced by any
* reader thread that may be in the midst of traversing table
* right now.
*/

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 list
if (next == null)
newTable[idx] = e;

else {
// Reuse trailing consecutive sequence at same slot
HashEntry<K,V> lastRun = e;     //这里注释说的很明白，就是为了重用链表上的已有节点
int lastIdx = idx;
for (HashEntry<K,V> last = next;  //这个for循环时为了找到rehash之后新的bucket 的Index不再改变的链表位置
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {          //找到可重用部分的链表头部
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;

// Clone all remaining nodes
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { //在重新hash的过程中只需要rehash到可重用链表头部就好了
int k = p.hash & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(p.key, p.hash,   //在rehash过程中所有的不可重用节点都是new出来的
n, p.value);     //这一点保证不会对原链表结构进行更改
}
}
}
}
table = newTable;
}

最近看了http://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/对ConcurrentHashMap的解读，自己也看了一下其中的源码，总是晕晕的，先简单总结一下。可以看到rehash过程的主要思路就是找到“重用点”，也就是图中的红色节点，途中虚线框中的节点构成了可重用的节点链表。