从入门到精通：ConcurrentHashMap的设计与实现

// 创建ConcurrentHashMap实例
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// 添加元素
map.put("apple", 10);
map.put("banana", 20);

// 获取元素
Integer value = map.get("apple");

// 删除元素
map.remove("banana");

// 遍历元素
map.forEach((key, val) -> System.out.println(key + ": " + val));

// 批量操作（原子性）
map.computeIfAbsent("orange", k -> 30);
map.computeIfPresent("apple", (k, v) -> v + 5);

ConcurrentHashMap
  └── Node<K,V>[] table       // 主数组，存储数据
        ├── Node<K,V>         // 普通节点
        ├── ForwardingNode    // 扩容时的转发节点
        ├── TreeBin           // 红黑树的根节点
        └── ReservationNode   // 用于computeIfAbsent等方法

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode()); // 特殊的哈希计算
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 检查头节点
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 处理红黑树或链表
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 遍历链表
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // CAS操作插入新节点
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 只锁定当前链表/红黑树的头节点
            synchronized (f) {
                // 插入或更新节点的逻辑...
            }
            // 检查是否需要转换为红黑树
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

// 如果key不存在，则计算并插入值
map.computeIfAbsent("key", k -> expensiveComputation(k));

// 如果key存在，则根据旧值计算新值
map.computeIfPresent("key", (k, v) -> v + 1);

// 无论key是否存在，都计算新值
map.compute("key", (k, v) -> v == null ? 1 : v + 1);

// 合并操作
map.merge("key", 1, (oldValue, newValue) -> oldValue + newValue);

// 业务标识对应的锁对象: 实现细粒度锁，避免全局锁竞争
private final ConcurrentHashMap<String, Object> lockMap = new ConcurrentHashMap<>();

public String getNextId(String bizTag) {
    // 1. 获取或创建业务标识对应的锁对象（每个业务一个锁，避免锁竞争）
    Object lock = lockMap.computeIfAbsent(bizTag, k -> new Object());

    // 2. 使用业务标识对应的锁进行同步操作
    synchronized (lock) {
        // 业务逻辑...
    }
}