并发容器之ConCurrentHashMap（二）

/**
 * 扩大哈希表的大小并重新打包条目，同时将给定的节点添加到新表中
 */
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K,V> node) {
    /*
     * 将每个链表中的节点重新分类到新表中。由于我们使用的是二次方扩展，
     * 因此每个桶中的元素要么保持在相同的索引位置，要么移动到一个二次方偏移量的位置。
     * 我们通过捕捉那些旧节点可以重用的情况来消除不必要的节点创建，因为它们的 next 字段不会改变。
     * 统计上，在默认阈值下，当表大小翻倍时，只有大约六分之一的节点需要克隆。
     * 当这些节点不再被任何正在遍历表的读取线程引用时，它们将是可垃圾回收的。
     * 条目的访问使用普通的数组索引，因为它们之后是易失的表写入。
     */
    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; // 用于计算索引的掩码
    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) { // 如果该桶中只有一个节点
                newTable[idx] = e; // 直接将该节点放到新表中
            } else { // 如果该桶中有多个节点，重用连续的节点序列
                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; // 将最后一个连续的节点放到新表中
                // 克隆剩余的节点
                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; // 计算新节点在新表中的索引
    node.setNext(newTable[nodeIndex]); // 设置新节点的下一个节点
    newTable[nodeIndex] = node; // 将新节点放到新表中
    table = newTable; // 更新表引用
}

/**
 * 返回指定键映射到的值，如果此映射不包含该键的映射，则返回 {@code null}。
 *
 * <p>更正式地说，如果此映射包含一个键 {@code k} 到值 {@code v} 的映射，
 * 使得 {@code key.equals(k)}，则此方法返回 {@code v}；
 * 否则返回 {@code null}。 (最多只能有一个这样的映射。)
 *
 * @throws NullPointerException 如果指定的键为 null
 */
public V get(Object key) {
    Segment<K,V> s; // 手动整合访问方法以减少开销
    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; // 如果没有找到匹配的键，返回 null
}