八股文之深入解析ConcurrentHashMap的线程安全实现机制

最新推荐文章于 2025-09-21 23:02:26 发布

原创最新推荐文章于 2025-09-21 23:02:26 发布 · 576 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#线程安全 #HashMap #ConHashMap

一、引言

在多线程并发编程中，HashMap是线程不安全的，而Hashtable通过全表锁机制保证线程安全但性能低下。ConcurrentHashMap作为Java并发包中的重要组件，在JDK1.8中进行了重大重构，采用了更精细的锁机制和优化策略，实现了高并发的线程安全访问。本文将深入代码层面，详细剖析ConcurrentHashMap在JDK1.8中的线程安全实现原理。

二、整体结构设计

JDK1.8的ConcurrentHashMap放弃了1.7中的分段锁（Segment）设计，改为以下核心结构：

transient volatile Node<K,V>[] table; // 哈希表数组
private transient volatile Node<K,V>[] nextTable; // 扩容时的新数组
private transient volatile int sizeCtl; // 控制标识符

关键改进：

使用Node数组作为主要存储结构
采用CAS+synchronized实现更细粒度的锁
扩容时支持多线程协助迁移

三、节点类型与内存可见性

ConcurrentHashMap定义了多种节点类型，均使用volatile保证内存可见性：

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保证next指针的可见性
    // ...
}

特殊节点类型：

ForwardingNode：扩容时使用的转发节点
TreeBin：红黑树根节点（当链表长度≥8时转换）
ReservationNode：占位节点

四、线程安全的核心机制

1. CAS操作保障原子性

ConcurrentHashMap大量使用Unsafe类的CAS操作：

// 获取数组中第i个元素的原子操作
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

// CAS方式设置数组元素
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

2. 精细化锁策略

JDK1.8采用更细粒度的锁机制：

无锁读取：get操作全程无锁，依赖volatile保证可见性
CAS尝试：put操作先尝试CAS插入
synchronized锁：当CAS失败时，对链表头/树根节点加synchronized锁

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // ...
    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) {
            // CASE 1: 桶为空，尝试CAS插入新节点
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break; // CAS成功则退出
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f); // 协助扩容
        else {
            V oldVal = null;
            synchronized (f) { // CASE 2: 对桶头节点加锁
                // 处理链表或树插入
            }
            // ...
        }
    }
    // ...
}

3. 并发扩容机制

当需要扩容时，ConcurrentHashMap支持多线程协同完成数据迁移：

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    // 每个线程负责一个区间段的迁移
    while (advance) {
        // 分配迁移任务区间
    }
    
    // 实际迁移操作
    synchronized (f) {
        // 链表/树节点迁移
    }
    
    // 设置ForwardingNode表示迁移完成
    setTabAt(tab, i, fwd);
}

关键点：

通过sizeCtl协调扩容状态
使用ForwardingNode标记已迁移的桶
其他线程遇到转发节点时会协助迁移

五、关键操作的线程安全分析

1. 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) {
            // 遍历链表
        }
    }
    return null;
}

线程安全保证：

通过volatile变量保证内存可见性
读操作全程无锁，不会阻塞
即使遇到扩容也能正确读取（通过ForwardingNode）

2. put操作（CAS+锁）

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 参数校验...
    for (Node<K,V>[] tab = table;;) {
        // CASE 1: 桶为空，CAS尝试插入
        if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
            break;
        
        // CASE 2: 桶正在迁移
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        
        // CASE 3: 桶非空且未迁移
        else {
            synchronized (f) { // 对头节点加锁
                // 检查是否仍为头节点（防止加锁前被修改）
                if (tabAt(tab, i) == f) {
                    // 链表插入或树插入
                }
            }
        }
    }
    // 更新size计数
    addCount(1L, binCount);
}

线程安全保证：

空桶插入：通过CAS保证原子性
非空桶：synchronized锁定头节点
扩容检测：遇到迁移中的桶会协助迁移
计数更新：使用LongAdder风格的计数器

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

线程安全保证：

采用分片计数（类似LongAdder）
baseCount + CounterCell[] 减少竞争
最终结果是弱一致性的近似值

六、扩容机制的线程安全

扩容是ConcurrentHashMap最复杂的部分，其线程安全通过以下方式保证：

状态控制：通过sizeCtl变量控制扩容状态

- 负数：表示正在初始化或扩容
- 正数：表示扩容阈值

协助迁移：

if ((fh = f.hash) == MOVED)
    tab = helpTransfer(tab, f);

桶迁移过程：

synchronized (f) {
    // 重新检查头节点
    if (tabAt(tab, i) == f) {
        // 拆分链表或树
        // 设置ForwardingNode
    }
}

七、红黑树处理的线程安全

当链表长度超过8时，会转换为红黑树：

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n;
    if (tab != null) {
        synchronized (b) {
            // 链表转树过程
            TreeNode<K,V> hd = null, tl = null;
            // 构建树结构
            setTabAt(tab, index, new TreeBin<K,V>(hd));
        }
    }
}

TreeBin内部通过读写锁保证线程安全：

static final class TreeBin<K,V> extends Node<K,V> {
    final TreeNode<K,V> root;
    volatile TreeNode<K,V> first;
    volatile Thread waiter;
    volatile int lockState;
    // 读写锁状态值
    static final int WRITER = 1; // 写锁
    static final int WAITER = 2; // 等待写锁
    static final int READER = 4; // 读锁
    
    // 加读锁
    private final void lockRoot() {
        // CAS尝试获取锁
    }
    
    // 释放读锁
    private final void unlockRoot() {
        lockState = 0;
    }
}

八、总结

JDK1.8的ConcurrentHashMap通过以下技术实现线程安全：

无锁读：volatile变量保证内存可见性
CAS写：空桶插入等简单操作使用CAS
细粒度锁：非空桶使用synchronized锁定头节点
协助扩容：多线程协同完成扩容迁移
分片计数：减少size统计的竞争
树结构优化：红黑树使用特殊读写锁