- 正确答案：HashMap 和 ConcurrentHashMap 都是 Java 中用于存储键值对的哈希表实现，但它们在并发处理、线程安全性和性能方面有显著区别。HashMap 是非线程安全的，适用于单线程环境；而 ConcurrentHashMap 是线程安全的，专为高并发场景设计，允许多个线程同时读写而不会导致数据不一致。 - 解答思路：首先明确两者的基本用途和所属包（java.util），然后从线程安全性、底层结构、并发控制机制、性能表现等方面进行对比分析。重点在于解释 ConcurrentHashMap 如何通过分段锁或 CAS + synchronized 实现高效并发，而 HashMap 在多线程环境下可能出现死循环、数据覆盖等问题。 - 深度知识讲解： 1. HashMap 底层原理： - 基于数组 + 链表/红黑树（JDK 8 后引入）实现。 - 存储结构：Entry 或 Node 节点组成的数组，每个桶（bucket）对应一个链表或红黑树。 - 插入流程： 1. 计算 key 的 hash 值：hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16) 2. 确定索引位置：index = (n - 1) & hash （n 为数组长度，始终为 2 的幂） 3. 若该位置为空，则直接插入；否则处理冲突（链表尾插或树化） - 扩容机制：当元素数量超过 threshold（capacity * loadFactor，默认 0.75），触发 resize()，容量翻倍，并重新计算所有元素的位置。 - 线程不安全原因： - 多线程 put 可能导致链表成环（JDK 7 头插法问题） - 扩容期间多个线程同时操作可能导致数据丢失或死循环 - 无同步机制保护共享变量（如 modCount）示例代码片段（简化版插入逻辑）： ``` final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node[] tab; Node p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n-1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // 尾插 if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } ``` 2. ConcurrentHashMap（以 JDK 8 为例）： - 改进了 JDK 7 的 Segment 分段锁机制，采用更轻量的 synchronized + CAS + volatile 实现。 - 底层结构同样是数组 + 链表/红黑树，但节点类型为 Node 或其子类（如 ForwardingNode）。 - 关键字段： - transient volatile Node[] table; - private transient volatile int sizeCtl; - -1: 表示正在初始化 - -(1 + n): 表示有 n 个线程正在扩容 - 正数：表示下一次扩容阈值 - 并发控制策略： - 插入时使用 CAS 操作尝试修改头节点（first node of bucket） - 如果桶为空，使用 CAS 设置第一个节点 - 如果桶已有节点，则对该桶的头节点加 synchronized 锁（JDK 8 后粒度细化到桶级别） - 扩容时使用 transferIndex 分配迁移任务给多个线程并行执行（协助扩容机制） - get 操作完全无锁：利用 volatile 保证可见性，读取无需同步 - size() 方法返回的是估算值（因为并发修改频繁），精确统计需调用 mappingCount() 核心方法 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[] tab = table;;) { Node f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); // CAS 初始化 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new Node(hash, key, value, null))) break; // 成功插入 } 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 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 pred = e; if ((e = e.next) == null) { pred.next = new Node(hash, key, value, null); break; } } } else if (f instanceof TreeBin) { // 红黑树 // ... tree insertion logic } } } if (binCount != 0) { if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } } addCount(1L, binCount); return null; } ``` 其中 tabAt、casTabAt 是基于 Unsafe 的 volatile 读写和 CAS 操作： ``` static final Node tabAt(Node[] tab, int i) { return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE); } static final boolean casTabAt(Node[] tab, int i, Node c, Node v) { return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v); } ``` 3. 扩展知识点对比： | 特性 | HashMap | ConcurrentHashMap | |------|--------|-------------------| | 线程安全 | 否 | 是 | | 实现方式 | 数组+链表/红黑树 | 数组+链表/红黑树 | | 锁机制 | 无 | synchronized + CAS | | 初始容量 | 16 | 16 | | 负载因子 | 0.75 | 0.75 | | 是否允许 null 键/值 | 允许（仅一个 null 键） | 不允许（会抛出 NullPointerException） | | 迭代器是否fail-fast | 是 | 是（但弱一致性，可能反映部分中间状态） | | 扩容方式 | 单线程 rehash | 多线程协助迁移（transfer） | | 性能 | 高（无锁） | 较高（细粒度锁） | 4. 使用建议： - 单线程环境优先使用 HashMap - 多线程环境下避免使用 Collections.synchronizedMap(new HashMap<>())，因其全局锁性能差 - 高并发读写场景推荐 ConcurrentHashMap - 若仅需并发读，可考虑使用 CopyOnWriteMap（适用于读远多于写的场景） 5. 常见面试延伸问题： - 为什么 ConcurrentHashMap 不允许 null 键？回答：为了避免歧义。get 返回 null 时无法判断是没找到还是值为 null，在并发环境中可能引发误解。 - JDK 7 和 JDK 8 的 ConcurrentHashMap 实现有何不同？回答：JDK 7 使用 Segment 分段锁（继承 ReentrantLock），默认 16 段，最大并发度 16；JDK 8 改为 CAS + synchronized 控制桶级锁，更加灵活高效。 - ConcurrentHashMap 如何实现扩容期间的线程安全访问？回答：使用 ForwardingNode 标记已迁移的桶，当线程访问该桶时会自动加入迁移任务；未迁移的桶仍可正常读写。总结：理解 HashMap 和 ConcurrentHashMap 的核心差异不仅在于“是否线程安全”，更要深入其底层实现机制，包括哈希计算、冲突解决、扩容策略、并发控制手段等。这些内容体现了 Java 集合框架的设计哲学——在性能与线程安全之间取得平衡。

美团后端面经

全站热榜

创作者周榜