// HashMap中的修改計(jì)數(shù)器
transient int modCount;

// 迭代器中保存的計(jì)數(shù)器快照
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);  // 這里會觸發(fā)fail-fast
}

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

new Thread(() -> {
    map.put(2, "Two");  // 可能觸發(fā)主線程迭代時(shí)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();
        // ...
    }
}

// 錯(cuò)誤方式（觸發(fā)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() 實(shí)現(xiàn)
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); // 新建普通節(jié)點(diǎn)
        if (tl == null)
            hd = p;
        else
            tl.next = p;
        tl = p;
    }
    return hd;
}

abstract class HashIterator {
    Node<K,V> next;        // 下一個(gè)返回的節(jié)點(diǎn)
    Node<K,V> current;     // 當(dāng)前節(jié)點(diǎn)
    int expectedModCount;  // 修改計(jì)數(shù)器快照
    
    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;  // 紅黑樹父節(jié)點(diǎn)
    TreeNode<K,V> left;    // 左子樹
    TreeNode<K,V> right;   // 右子樹
    TreeNode<K,V> prev;    // 鏈表前驅(qū)節(jié)點(diǎn)（刪除時(shí)需要）
    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構(gòu)造時(shí)檢查內(nèi)存
if (remaining < treeNodeSpace) {
    untreeify(); // 立即退化為鏈表
    return;
}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // 父節(jié)點(diǎn)指針
    TreeNode<K,V> left;    // 左子樹指針
    TreeNode<K,V> right;   // 右子樹指針
    TreeNode<K,V> prev;    // 前驅(qū)節(jié)點(diǎn)（仍保留鏈表結(jié)構(gòu)）
    boolean red;          // 顏色標(biāo)記
}

// 檢查桶的樹化情況
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實(shí)現(xiàn)
@Override
public int hashCode() {
    return Objects.hash(field1, field2, field3); 
}

// 預(yù)設(shè)足夠大的initialCapacity
new HashMap<>(expectedSize * 2);