为什么ConcurrentHashMap是线程安全的？

ConcurrentHashMap的线程安全机制

ConcurrentHashMap是Java并发包中提供的一个线程安全的哈希表实现，它通过多种技术手段实现了高效的并发访问。下面我将详细分析ConcurrentHashMap是如何保证线程安全的。

1. 核心设计思想

ConcurrentHashMap的设计目标是在保证线程安全的前提下，提供比Hashtable和Collections.synchronizedMap()更高的并发性能。它通过锁分段技术（Java 7及之前）或CAS操作与synchronized结合（Java 8及之后）来实现这一目标。

2. Java 7的实现机制：分段锁

在Java 7中，ConcurrentHashMap采用分段锁（Segment）的设计，将数据分为多个段，每个段有自己的锁。

// Java 7中的ConcurrentHashMap结构简示
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
        implements ConcurrentMap<K, V>, Serializable {
    
    // 将整个数据分成多个段，每个段有自己的锁
    final Segment<K,V>[] segments;
    
    // Segment类，继承自ReentrantLock
    static final class Segment<K,V> extends ReentrantLock implements Serializable {
        transient volatile HashEntry<K,V>[] table;  // 每个段维护自己的哈希表
        // ...
    }
    
    // 哈希表条目
    static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;  // 使用volatile保证可见性
        volatile HashEntry<K,V> next;  // 使用volatile保证可见性
    }
}

2.1 分段锁工作原理

数据分段：ConcurrentHashMap内部将数据分成多个Segment（默认16个），每个Segment类似于一个小的Hashtable。
独立锁：每个Segment都有自己的锁（ReentrantLock），操作不同Segment的数据时，不会相互阻塞。
锁粒度：锁的粒度是Segment级别，而不是整个Map，这大大提高了并发度。

--- title: ConcurrentHashMap分段锁结构 --- graph TD A[ConcurrentHashMap] --> B[Segment 1] A --> C[Segment 2] A --> D[Segment 3] A --> E[Segment N] B --> F[HashEntry[]] C --> G[HashEntry[]] D --> H[HashEntry[]] E --> I[HashEntry[]] F --> J[Entry 1] F --> K[Entry 2] G --> L[Entry 1] G --> M[Entry 2] B -.->|拥有锁| B C -.->|拥有锁| C D -.->|拥有锁| D E -.->|拥有锁| E

2.2 分段锁的优缺点

优点：

多个线程可以同时访问不同Segment的数据，提高了并发度
在理想情况下，并发度等于Segment的数量

缺点：

Segment数量一旦初始化就不能改变
在某些操作（如size()）时需要锁定所有Segment，性能较差
内存占用较大，因为每个Segment都有自己的HashEntry数组

3. Java 8的实现机制：CAS与synchronized

Java 8对ConcurrentHashMap进行了重构，放弃了分段锁的设计，转而采用CAS（Compare And Swap）操作和synchronized关键字相结合的方式。

// Java 8中的ConcurrentHashMap结构简示
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
    
    // Node数组，替代了Segment数组
    transient volatile Node<K,V>[] table;
    
    // Node类，替代了HashEntry
    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保证可见性
    }
    
    // 特殊节点：ForwardingNode，用于扩容
    static final class ForwardingNode<K,V> extends Node<K,V> {
        final Node<K,V>[] nextTable;
        // ...
    }
}

3.1 CAS操作与synchronized结合

Java 8的ConcurrentHashMap主要通过以下机制保证线程安全：

CAS操作：在无竞争的情况下，使用CAS操作更新节点，避免加锁
synchronized：在发生哈希冲突时，使用synchronized锁定链表或红黑树的头节点
volatile变量：使用volatile保证变量的可见性
特殊节点：使用ForwardingNode等特殊节点处理扩容等特殊情况

--- title: Java 8 ConcurrentHashMap操作流程 --- flowchart TD A[开始put操作] --> B{计算hash值} B --> C{对应桶是否为空?} C -->|是| D[CAS设置头节点] C -->|否| E{头节点类型?} E -->|ForwardingNode| F[协助扩容] E -->|普通节点| G[synchronized锁定头节点] G --> H[遍历链表/树更新或添加节点] D --> I[操作完成] F --> I H --> I

3.2 关键操作的线程安全实现

3.2.1 put操作

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锁定头节点
            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;
                        }
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);  // 链表转红黑树
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);  // 更新计数
    return null;
}

3.2.2 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());
    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;
}

get操作不需要加锁，因为Node的val和next字段都被volatile修饰，保证了可见性。

3.2.3 size操作

Java 8的ConcurrentHashMap不再像Java 7那样需要锁定所有Segment来计算size，而是使用计数器和CAS操作来维护一个近似值。

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) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

4. volatile变量的使用

ConcurrentHashMap中大量使用了volatile变量来保证可见性，这是其线程安全的重要保障。

// Node类中的volatile字段
static class Node<K,V> implements Map.Entry<K,V> {
    volatile V val;       // 保证值的可见性
    volatile Node<K,V> next;  // 保证链表指针的可见性
}

// table数组使用volatile修饰
transient volatile Node<K,V>[] table;

volatile关键字的作用：

可见性：当一个线程修改了volatile变量，新值会立即同步到主内存，其他线程读取时会从主内存读取，保证了可见性
禁止指令重排序：volatile变量的读写操作不会被重排序，保证了操作的有序性

5. 与其他线程安全Map的对比

特性	ConcurrentHashMap	Hashtable	Collections.synchronizedMap
锁机制	分段锁/CAS+synchronized	对整个表加锁	对整个表加锁
锁粒度	桶级别/节点级别	表级别	表级别
并发性能	高	低	低
迭代器	弱一致性，不抛ConcurrentModificationException	快速失败，抛ConcurrentModificationException	快速失败，抛ConcurrentModificationException
null值	允许key和value为null	不允许key和value为null	取决于被包装的Map

6. 特殊的并发处理机制

6.1 扩容机制

ConcurrentHashMap的扩容是一个特殊的过程，它允许多个线程同时参与扩容，提高了效率。

--- title: ConcurrentHashMap扩容过程 --- sequenceDiagram participant Thread1 participant Thread2 participant ConcurrentHashMap Thread1->>ConcurrentHashMap: 开始扩容 ConcurrentHashMap-->>Thread1: 创建新表 Thread1->>ConcurrentHashMap: 设置ForwardingNode Thread1->>ConcurrentHashMap: 迁移部分数据 Thread2->>ConcurrentHashMap: 访问数据 ConcurrentHashMap-->>Thread2: 检测到ForwardingNode Thread2->>ConcurrentHashMap: 帮助扩容 Thread2->>ConcurrentHashMap: 迁移部分数据 Thread1->>ConcurrentHashMap: 完成扩容 ConcurrentHashMap-->>Thread1: 替换表引用

6.2 计数器机制

Java 8的ConcurrentHashMap使用了一个特殊的计数器机制来统计元素数量，避免了全局锁。

// 基础计数器
private transient volatile long baseCount;

// 计数器单元格数组，用于高并发情况下的计数
private transient volatile CounterCell[] counterCells;

// 计数器单元格
@sun.misc.Contended static final class CounterCell {
    volatile long value;
    CounterCell(long x) { value = x; }
}

7. 总结

ConcurrentHashMap的线程安全性主要通过以下机制实现：

Java 7：采用分段锁技术，将数据分为多个段，每个段有自己的锁，不同段的操作可以并行执行。
Java 8：采用CAS操作和synchronized相结合的方式，在无竞争时使用CAS，有竞争时使用synchronized锁定头节点。
volatile变量：大量使用volatile变量保证可见性，如Node的val和next字段。
特殊设计：如ForwardingNode处理扩容，CounterCell处理计数等。
弱一致性迭代器：迭代器不保证反映最新的修改，但不会抛ConcurrentModificationException。

这些设计使得ConcurrentHashMap在保证线程安全的同时，提供了比Hashtable和Collections.synchronizedMap()更高的并发性能，特别适合高并发场景下的使用。

参考资料

account_tree

思维导图

Interview AiBoxInterview AiBox — 面试搭档

不只是准备，更是实时陪练

Interview AiBox 在面试过程中提供实时屏幕提示、AI 模拟面试和智能复盘，让你每一次回答都更有信心。

免费下载 Interview AiBoxdownload 查看价格方案sell

AI 助读

一键发送到常用 AI

ConcurrentHashMap通过多种机制保证线程安全：Java 7采用分段锁技术，将数据分为多个段，每个段有自己的锁，提高并发度；Java 8改用CAS操作与synchronized结合，无竞争时用CAS，有竞争时锁定头节点。同时大量使用volatile变量保证可见性，特殊设计如ForwardingNode处理扩容，CounterCell处理计数等。这些设计使其在保证线程安全的同时，比Hashtable和synchronizedMap提供更高的并发性能。

智能总结

深度解读

考点定位

思路启发