JDK8 HashMap红黑树退化为链表的机制方式

// HashMap中的修改计数器
transient int modCount;

// 迭代器中保存的计数器快照
int expectedModCount;

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);

Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
    String key = it.next();
    map.put("C", 3);  // 这里会触发fail-fast
}

Map<Integer, String> map = new HashMap<>();
map.put(1, "One");

new Thread(() -> {
    map.put(2, "Two");  // 可能触发主线程迭代时fail-fast
}).start();

for (Integer key : map.keySet()) {  // 可能抛出异常
    System.out.println(key);
}

// HashMap中的修改操作都会增加modCount
public V put(K key, V value) {
    // ...
    ++modCount;
    // ...
}

public V remove(Object key) {
    // ...
    ++modCount;
    // ...
}

public void clear() {
    // ...
    ++modCount;
    // ...
}

final class KeyIterator extends HashIterator 
    implements Iterator<K> {
    public final K next() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        // ...
    }
}

// 错误方式（触发fail-fast）
for (String key : map.keySet()) {
    if (key.equals("remove")) {
        map.remove(key);  // 直接修改原集合
    }
}

// 正确方式（使用迭代器的remove）
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
    if (it.next().equals("remove")) {
        it.remove();  // 不会增加modCount
    }
}

synchronized(map) {
    for (String key : map.keySet()) {
        // 操作代码
    }
}

// 检测异常频率
try {
    for (Entry<K,V> e : map.entrySet()) {
        // ...
    }
} catch (ConcurrentModificationException ex) {
    metrics.record("fail-fast.triggered");
}

// HashMap.treeifyBin() 片段
if (binCount >= TREEIFY_THRESHOLD - 1) { // TREEIFY_THRESHOLD=8
    if (tab.length < MIN_TREEIFY_CAPACITY) // MIN_TREEIFY_CAPACITY=64
        resize();
    else
        treeifyBin(tab, hash);
}

// HashMap.resize() 片段
if (lc <= UNTREEIFY_THRESHOLD)  // UNTREEIFY_THRESHOLD=6
    tab[index] = loHead.untreeify(map);

// TreeNode.untreeify() 实现
final Node<K,V> untreeify(HashMap<K,V> map) {
    Node<K,V> hd = null, tl = null;
    for (TreeNode<K,V> q = this; q != null; q = q.next) {
        Node<K,V> p = map.replacementNode(q, null); // 新建普通节点
        if (tl == null)
            hd = p;
        else
            tl.next = p;
        tl = p;
    }
    return hd;
}

abstract class HashIterator {
    Node<K,V> next;        // 下一个返回的节点
    Node<K,V> current;     // 当前节点
    int expectedModCount;  // 修改计数器快照
    
    final Node<K,V> nextNode() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        // ...
    }
}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // 红黑树父节点
    TreeNode<K,V> left;    // 左子树
    TreeNode<K,V> right;   // 右子树
    TreeNode<K,V> prev;    // 链表前驱节点（删除时需要）
    boolean red;
    // 仍然保留next指针（继承自Entry）
}

// TreeNode既保持hash值又维持链表顺序
Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
    return new Node<>(p.hash, p.key, p.value, next);
}

try {
    treeifyBin(tab, hash);
} catch (Throwable t) {
    tab[index] = originalHead; // 回退到原链表
    throw t;
}

// TreeNode构造时检查内存
if (remaining < treeNodeSpace) {
    untreeify(); // 立即退化为链表
    return;
}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // 父节点指针
    TreeNode<K,V> left;    // 左子树指针
    TreeNode<K,V> right;   // 右子树指针
    TreeNode<K,V> prev;    // 前驱节点（仍保留链表结构）
    boolean red;          // 颜色标记
}

// 检查桶的树化情况
Field tableField = HashMap.class.getDeclaredField("table");
tableField.setAccessible(true);
Node<?,?>[] table = (Node<?,?>[]) tableField.get(map);

int trees = 0;
for (Node<?,?> node : table) {
    if (node instanceof TreeNode) trees++;
}

// 好的hashCode实现
@Override
public int hashCode() {
    return Objects.hash(field1, field2, field3); 
}

// 预设足够大的initialCapacity
new HashMap<>(expectedSize * 2);