Java并发实战：ConcurrentHashMap原理与常见面试题

原创于 2025-11-06 14:44:29 发布 · 1.3k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #面试 #开发语言 #性能优化

面试题专栏收录该内容

13 篇文章

订阅专栏

博客主页：天天困啊
系列专栏：面试题
关注博主，后期持续更新系列文章
如果有错误感谢请大家批评指出，及时修改
感谢大家点赞👍收藏⭐评论✍

前言

在上几篇文章中我已经给大家从原理上讲解了List集合和Set集合并发的一些常考知识和面试题，今天给大家要讲解的就是Map的并发

我们还是依旧摆脱无聊的文字，从代码上给大家讲解

首先我们先自己模拟一下多线程并发，看看Map是否是线程安全的

/**
 * @author 天天困
 * @date 2025/11/6
 */
public class Test01 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        for (int i = 1; i <= 30; i++){
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}

我们运行这个代码之后就会在控制台看到如下的信息：

在控制台中我们可以看到报错信息ConcurrentModificationException 异常

产生这个异常主要是由于多线程并发修改HashMap导致的。当一个线程正在遍历或打印map的内容时，另一个线程同时修改了map结构，就会触发此异常。

解决方案

方案一同步代码块

/**
 * @author 天天困
 * @date 2025/11/6
 */
public class Test01 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                synchronized (map) {
                    map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                    System.out.println(map);
                }
            }, String.valueOf(i)).start();
        }
    }
}

因为HashMap的put操作等都不是原子性，多线程同时访问会引ConcurrentModificationException 异常。那我们最先考虑到的就是通过synchronized关键字，实现互斥访问。同一时刻只有一个线程能执行synchronized代码块，避免了在遍历过程中HashMap结构被修改的情况

方案二 ConcurrentHashMap

/**
 * @author 天天困
 * @date 2025/11/6
 */
public class Test01 {
    public static void main(String[] args) {
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}

我们可以使用util包下的并发类中自带的ConcurrentHashMap来保证线程安全

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) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                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;
    }

上述是jdk1.8以后ConcurrentHashMap中put操作的源码，从源码中我们可以看到它使用CAS+synchronized

简单插入-使用CAS

// 当桶(bucket)为空时，使用CAS无锁操作
if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
    // CAS原子操作，无锁化处理
    if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
        break;  // 插入成功
}

复杂操作-使用synchronized

// 当桶不为空，需要处理链表或红黑树时，使用synchronized
else {
    V oldVal = null;
    synchronized (f) {  // 只锁定当前桶的头节点
        // 处理链表操作、红黑树操作等复杂逻辑
    }
}

设计理念

性能优化：大部分简单操作通过CAS完成，避免锁开销
正确性保证：复杂操作使用传统锁机制确保线程安全
粒度控制：只锁定必要的数据结构，提高并发度

为什么这样设计

CAS的优势：无锁、低延迟、高并发
CAS的局限：只能处理简单的原子操作
synchronized：处理复杂的业务逻辑和数据结构变更

这样混合策略既保证了高性能、又确保了线程安全

我在上述给大家讲解ConcurrentHashMap中put操作的源码时说了一句jdk1.8以后是这样的，那难道jdk1.8之前的put逻辑和源码和jdk1.8以后不一样？没错是这样的。从这里就可以引发一道经典的面试题，接下来就是跟ConcurrentHashMap有关的面试题环节

常考面试题

Java中ConcurrentHashMap 1.7和1.8之间的区别

JDK1.7中HashMap采用数组+链表的数据结构，ConcurrentHashMap采用分段锁来实现高并发，分段锁的机制是每个Segment独立，最多支持16个线程并发执行也是默认的线程数量
JDK1.8中HashMap是数组+链表+红黑树的数据结构，优化了JDK1.7中数组扩容的方案，解决了Entry链死循环和数据丢失问题。对锁的粒度进行了优化，锁在链表或红黑树的节点级别进行，CAS用于无锁插入，synchronized仅需要处理复杂逻辑时使用，并且只锁点头节点。这样锁粒度更细，并发度更高