JDK 8 ConcurrentHashMap 详解及详细源码展示

JDK 8 ConcurrentHashMap 详解与源码分析

原创已于 2025-06-24 22:47:00 修改 · 464 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#JDK8 #源码 #学习

于 2025-06-22 08:04:39 首次发布

源码学习专栏收录该内容

118 篇文章

订阅专栏

JDK 8 `ConcurrentHashMap` 详解

Java 8 中的 ConcurrentHashMap 是一个线程安全的哈希表，它摒弃了 JDK 7 中的分段锁机制，采用 CAS + synchronized 实现更细粒度的并发控制，大幅提升了多线程环境下的性能。以下是其核心原理和源码分析。

一、核心概念

1. 数据结构

数组 + 链表 + 红黑树：与 HashMap 类似，但通过 CAS 和 synchronized 保证线程安全。
Node 节点：存储键值对，用 volatile 修饰 next 字段保证可见性。
TreeBin 节点：当链表长度超过 8 且数组长度≥64 时，转换为红黑树，由 TreeBin 管理树节点。

2. 关键参数

初始容量：16（默认），必须是 2 的幂。
负载因子：0.75f，触发扩容的阈值。
并发度：默认支持 16 个线程并发，通过数组分段实现。

3. 锁机制

CAS（Compare-And-Swap）：用于初始化数组、调整大小和更新头节点。
synchronized：仅锁定链表或红黑树的头节点，锁粒度更细。

二、源码解析

1. Node 节点结构

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;         // 使用volatile保证可见性
    volatile Node<K,V> next; // 使用volatile保证可见性

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()       { return key; }
    public final V getValue()     { return val; }
    public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
    public final String toString(){ return key + "=" + val; }
    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    public final boolean equals(Object o) {
        Object k, v, u; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == (u = val) || v.equals(u)));
    }

    /**
     * Virtualized support for map.get(); overridden in subclasses.
     */
    Node<K,V> find(int h, Object k) {
        Node<K,V> e = this;
        if (k != null) {
            do {
                K ek;
                if (e.hash == h &&
                    ((ek = e.key) == k || (ek != null && k.equals(ek))))
                    return e;
            } while ((e = e.next) != null);
        }
        return null;
    }
}

2. put 方法

public V put(K key, V value) {
    return putVal(key, value, false);
}

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;
        // 1. 如果数组为空，初始化数组
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        // 2. 如果指定位置为空，CAS插入新节点
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 3. 如果正在扩容，协助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 4. 锁定头节点，处理链表或红黑树
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 链表节点
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) { // 红黑树节点
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            // 5. 判断是否需要转换为红黑树
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 6. 增加计数，检查是否需要扩容
    addCount(1L, binCount);
    return null;
}

3. initTable 初始化数组

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // sizeCtl为-1表示有线程正在初始化，当前线程让出CPU
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // CAS将sizeCtl设为-1，表示正在初始化
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2); // 计算下次扩容阈值 (0.75n)
                }
            } finally {
                sizeCtl = sc; // 设置扩容阈值
            }
            break;
        }
    }
    return tab;
}

4. get 方法

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode()); // 计算哈希值
    // 1. 数组不为空且索引位置有元素
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 2. 头节点直接匹配
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 3. 红黑树节点，调用TreeBin的find方法
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 4. 链表节点，遍历查找
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

5. size 方法

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount; // 基础计数
    if (as != null) {
        // 累加所有CounterCell的值
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

三、关键特性分析

1. 分段锁升级为CAS + synchronized

JDK 7 使用分段锁（Segment），每个 Segment 独立加锁，锁粒度较大。
JDK 8 直接锁定头节点，锁粒度更细，并发度更高。

2. 并发扩容机制

当某个线程发现需要扩容时，会发起扩容操作，并通过 transfer 方法将原数组元素迁移到新数组。
其他线程发现正在扩容时，会协助迁移数据，提高扩容效率。

3. CounterCell 计数器

size() 方法通过 baseCount 和 CounterCell 数组累加元素数量。
多线程并发修改时，通过 CAS 更新 baseCount，冲突时使用 CounterCell 减少竞争。

四、线程安全性

原子操作：通过 Unsafe 类的 CAS 方法保证原子性（如 casTabAt）。
可见性：通过 volatile 修饰数组和节点保证可见性。
锁机制：仅锁定链表或红黑树的头节点，锁粒度极小。

五、使用建议

高并发场景首选：相比 Collections.synchronizedMap 和 JDK 7 的 ConcurrentHashMap，性能更优。
避免批量操作：putAll、clear 等方法仍需全局加锁，尽量避免在高并发时使用。
合理初始化容量：预估元素数量，减少扩容次数，提高性能。

六、总结

JDK 8 的 ConcurrentHashMap 通过 CAS + synchronized 实现了更细粒度的并发控制，同时引入红黑树优化了哈希冲突时的性能。其设计巧妙地平衡了线程安全和性能，是高并发场景下的首选哈希表实现。理解其核心原理（锁机制、扩容机制、计数方式）对于正确使用和调优至关重要。