本文是「2026 Java 后端面试连载」第 8 篇。前 7 篇已覆盖 Java 并发、Redis、MySQL、JVM 调优、Spring 原理、消息队列与分布式事务、高并发场景设计,链接见文末。本篇回到 Java 基础层,只写集合容器源码这一条线——与第 1 篇的线程池、AQS、锁升级严格不重叠。
题目来源说明
本文题目来自两类公开材料,不是编的:
- 公开招聘 JD 样本:基于 38 期公开招聘 JD 样本统计(BOSS 直聘、拉勾、猎聘等平台在招岗位),「JVM / 并发 / Java 基础」平均提及率 61%,位列第 5;其中「HashMap 与集合容器」考点在 30 期样本中出现、去重后 38 个题变体,在 29 个考点簇中排名第 8——它几乎是每份 JD 里「Java 基础扎实」这句话的唯一可验证抓手。
- 公开面经:牛客、CSDN、稀土掘金等公开面经。字节/腾讯的「追问式连环八股」把 HashMap 当作开场第一环(树化阈值为什么是 8、退化为什么是 6 → ConcurrentHashMap JDK7/8 差异 → 线程池 7 参数 → volatile),拼多多一面直接考「HashMap 演进史 + 泊松分布数学依据」,建行开发岗真题明确问「负载因子 0.75 下链长到 8 的概率」并追问「1.7 头插死循环 → 1.8 尾插 → 为什么还线程不安全 → ConcurrentHashMap」,美团一面考「两个超大集合找重复元素」,快手考「迭代中 remove 报 CME」。
面试官问法千变万化,考察的决策链是固定的:原理(数据结构为什么这么设计)→ 现象(什么写法在线上炸成什么样)→ 排查(出事看哪里、怎么确认)→ 选型(业务里到底用哪个 Map)。本文按这条链组织,先给速查表,再逐题拆。
速查表一:HashMap 的 6 个魔法数字
| 常量 | 值 | 一旦被追问,必须答出的理由 |
|---|---|---|
默认容量 DEFAULT_INITIAL_CAPACITY | 16 | 2 的幂,使 (n-1) & hash 等价于取模但更快;16 是「小到不浪费、大到不易碰撞」的经验值 |
负载因子 DEFAULT_LOAD_FACTOR | 0.75 | 空间与时间的折中;0.75 下桶内节点数服从 λ≈0.5 的泊松分布,碰撞概率已被压到很低 |
树化阈值 TREEIFY_THRESHOLD | 8 | λ=0.5 时桶内 8 个节点的概率约 6×10⁻⁸,树化是防御哈希碰撞攻击的兜底,不是常规路径 |
退化阈值 UNTREEIFY_THRESHOLD | 6 | 与 8 之间留 7 作缓冲带,避免桶在 7↔8 抖动时反复树化/退化(两者都是 O(n) 操作) |
最小树化容量 MIN_TREEIFY_CAPACITY | 64 | 表还小时优先扩容而不是树化——扩容能把碰撞节点分散开,成本更低 |
最大容量 MAXIMUM_CAPACITY | 1<<30 | int 正数范围内最大的 2 的幂;再大 (n-1) & hash 也不会更分散 |
速查表二:JDK 7 与 JDK 8 的 HashMap / CHM 差异
| 维度 | HashMap 1.7 | HashMap 1.8 | ConcurrentHashMap 1.7 | ConcurrentHashMap 1.8 |
|---|---|---|---|---|
| 数据结构 | 数组 + 链表 | 数组 + 链表 + 红黑树 | Segment[] + HashEntry[] + 链表 | Node[] + 链表 + 红黑树 |
| 插入方式 | 头插 | 尾插 | 头插(HashEntry.next 为 final) | 尾插 |
| 并发控制 | 无 | 无 | 分段锁(Segment 继承 ReentrantLock) | 空桶 CAS + 非空桶 synchronized 锁首节点 |
| 并发度 | — | — | 上限 = 段数(默认 16) | 约等于桶数量 |
| 扩容 | 逐桶 rehash,头插导致逆序 | 高低位拆分 (e.hash & oldCap),保持相对顺序 | 段内扩容 | 多线程协作迁移 + ForwardingNode 转发 |
| size 统计 | 直接返回 size 字段 | 直接返回 size 字段 | 先无锁试算两次,不一致再加锁全段统计 | baseCount + CounterCell[] 分散累加 |
| 是否允许 null | key/value 都允许 | key/value 都允许 | 都不允许 | 都不允许 |
速查表三:业务里选哪个 Map
| 场景 | 选择 | 一句话理由 |
|---|---|---|
| 单线程/方法内临时聚合 | HashMap | 无同步开销,最快 |
| 需要按插入序或访问序遍历 | LinkedHashMap | 额外双向链表维持顺序,LRU 就靠 accessOrder=true |
| 需要按 key 排序/范围查询 | TreeMap | 红黑树,subMap/floorKey 只有它有 |
| 多线程读写同一个 Map | ConcurrentHashMap | 桶级锁 + 无锁读,唯一的生产答案 |
| 读多写极少、且要求强一致快照 | Collections.unmodifiableMap + 整体替换 | 不可变对象发布,读侧零同步 |
| 本地缓存带淘汰 | LinkedHashMap 覆写 removeEldestEntry 或 Caffeine | 前者手写够用,后者带 W-TinyLFU 更抗污染 |
一、把 put 流程讲成一条带判断的流水线
原理。很多人背「先算 hash 再找桶再插链表」,但面试官要的是分支条件。JDK 8 的 putVal 一共 6 个判断点,按顺序说清楚就不会被问倒:
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // ① 懒初始化,第一次 put 才分配 16
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); // ② 桶空,直接放(1.8 无锁;CHM 这里是 CAS)
else {
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p; // ③ 桶首就是目标 key,记下来准备覆盖
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)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); // ⑥ 链长到 8:可能树化,也可能只是扩容
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break; // 链中找到同 key,跳出准备覆盖
p = e;
}
}
if (e != null) { V oldValue = e.value; if (!onlyIfAbsent) e.value = value; return oldValue; }
}
++modCount;
if (++size > threshold) resize(); // ⑦ 先加 size 再判断,扩容在插入之后
return null;
}
三个容易被追问的细节:
- 为什么
index = (n-1) & hash而不是hash % n:n 是 2 的幂时两者等价,但位运算没有除法指令的延迟;这也是容量必须强制为 2 的幂的原因(tableSizeFor把任意初始容量向上取到 2 的幂)。 - 为什么 hash 要先扰动:
h ^ (h >>> 16)把高 16 位混进低 16 位。因为(n-1) & hash只用到低位,若直接用hashCode(),高位差异全被丢弃,一批只在高位不同的 key 会挤进同一个桶。 treeifyBin不等于必然树化:进方法后第一件事是判断tab.length < MIN_TREEIFY_CAPACITY(64),成立就resize()返回。所以「链表到 8 一定变红黑树」是错的——表长不足 64 时只会扩容。
二、树化阈值 8 的数学依据与 6 的缓冲意义
原理。HashMap 源码注释里直接给了泊松分布表,这是全网最爱考、也最容易答成「背数字」的一题。要在数学上讲清楚三件事:
第一,8 的前提是理想哈希。 负载因子 0.75、容量 n 的表中,任一桶内节点数近似服从参数 λ≈0.5 的泊松分布,源码注释给出的概率是:
| 桶内节点数 | 概率 |
|---|---|
| 0 | 0.60653066 |
| 1 | 0.30326533 |
| 2 | 0.07581633 |
| 3 | 0.01263606 |
| 4 | 0.00157952 |
| 5 | 0.00015795 |
| 6 | 0.00001316 |
| 7 | 0.00000094 |
| 8 | 0.00000006 |
也就是说,桶内出现 8 个节点的概率约为千万分之六。据此可以推出一个很硬的结论:正常的、hashCode 分布良好的业务里,红黑树几乎永远不会被创建。所以「树化是为了提升查询性能」这句话必须加限定——它只在哈希被恶意构造(HashDoS)或 hashCode 实现劣质时才是救命的。把这句话说准,比背概率数字得分高得多。
第二,为什么是 8 而不是更小。 树节点的内存约是普通节点的 2 倍(TreeNode 还额外维护 parent/left/right/prev/red),且树化/退化本身是 O(n) 的重建。阈值取 8 是把「极低概率触发」和「触发后 O(log n) 兜底」两个目标压在一起的平衡点:低于 8 会为了极小概率的极端场景长期付出内存代价;高于 8 则恶意碰撞时链表已经很长,防护失效。
第三,为什么退化是 6 而不是 7。 这是滞回(hysteresis)设计,跟电路里的施密特触发器一个思路:如果树化阈值 8、退化阈值也是 8,那么桶里节点数在 7 和 8 之间抖动时会反复 treeifyBin ↔ untreeify,每次都是重建整条结构的 O(n) 操作,性能会剧烈抖动。留 7 作为缓冲带,只有降到 6 才退化,抖动一次至少要跨 2 个节点才可能发生。
追问:树化之后查询复杂度到底是多少? 桶内是链表时是 O(n);是红黑树时是 O(log n),但常量更大(比较、旋转、颜色维护),所以链长 2、3 的桶用树反而更慢——这也解释了为什么阈值不能设小。TreeNode 同时保留 prev/next 双向链,是为了在退化(untreeify)时能 O(n) 重建链表,不用重新遍历树。
三、1.7 头插死循环:一条线上 CPU 100% 的经典事故
现象。这条是「原理→现象」链上最有画面感的一题。JDK 7 的 HashMap 在并发扩容时可能把链表接成环,之后任何一次 get 命中该桶,就会在 e = e.next 上无限循环——线程不会 BLOCKED、不会抛异常,只是CPU 打满、接口全部超时,重启即恢复,隔几天复发一次,排查难度极高。
原理。JDK 7 的 transfer() 是「逐个头插」:
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while (null != e) {
Entry<K,V> next = e.next; // ① 先记住下一个
if (rehash) e.hash = null == e.key ? 0 : hash(e.key);
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i]; // ② 头插到新桶
newTable[i] = e;
e = next; // ③ 前进
}
}
}
设旧桶里是 A → B,两个线程同时扩容:
| 时刻 | 线程 T1 | 线程 T2 | 桶状态 |
|---|---|---|---|
| t1 | 读到 e=A,next=B,时间片用完挂起 | — | 旧桶 A→B |
| t2 | — | 完整迁移,头插两次 | 新桶 B→A |
| t3 | 恢复,按记忆的 next=B 继续,把 A 头插到 B 前面 | — | 新桶 A→B,且 B.next 仍指向 A |
| t4 | — | — | 形成 A→B→A 环,get 永不到 null |
关键在 t3:T1 记下的 next=B 是旧表的指针,而 T2 已经把 B 的 next 改成了 A。T1 恢复后用旧指针继续头插,就制造出双向指向。
排查。线上遇到「CPU 100% 且线程栈停在 HashMap.get / getEntry」的处置顺序:
top -Hp <pid>找出高 CPU 线程,printf '%x'转十六进制,jstack <pid> | grep -A 30 <nid>看栈顶;若多条线程都停在java.util.HashMap.getEntry,基本可判定成环(不是死锁,所以看不到BLOCKED)。jmap -dump拿堆,MAT 里看该 HashMap 的某个桶,节点next指针成环即为铁证;也可搜HashMap$Entry数量异常。- 根因不在 HashMap,在使用方式:这类现场 99% 是「本地缓存」被多个业务线程无锁写(
private static Map cache = new HashMap()),并发扩容时踩上。 - 修复优先级:① 换
ConcurrentHashMap(根治);② 若只是启动时构建、之后只读,用Collections.unmodifiableMap或Map.copyOf在发布前冻结,并加final;③ 退一步用Collections.synchronizedMap,但它是全表锁,只在极低并发下可接受。
选型。这一题真正考的是「什么时候可以放心用 HashMap」:要么单线程独占,要么构建完成后只读。只要存在「运行期并发写」,答案就是 ConcurrentHashMap,不是「加个 synchronized 包一下」——包一层就等于把并发度降到 1。
四、1.8 改成尾插之后,为什么依然线程不安全
这是本簇最容易被答错的追问。很多人的答案是「尾插不会成环,所以 1.8 的 HashMap 是线程安全的」——错。尾插只消除了「成环」这一种最恶劣的表现,其他并发问题一个都没解决:
| 并发场景 | 后果 | 原因 |
|---|---|---|
| 两个线程同时往空桶 put | 一个元素被覆盖丢失 | 1.8 用 tab[i] = newNode(...) 直接赋值,不是 CAS,无原子性 |
两个线程同时 ++size | size 偏小,进而扩容时机偏晚,链越来越长 | size 是普通 int 字段,++ 非原子 |
一个线程在 treeifyBin/resize,另一个在 put | 桶结构错乱、节点丢失、树化过程中链表被截断 | 迁移与插入没有互斥 |
| 一个线程 put 完,另一个线程 get | 可能读到 null 或旧值 | Node.value 不是 volatile,无可见性保证 |
| 并发扩容 | 元素丢失或重复(同一节点被迁移两次) | 高低位拆分依赖读到的 next 稳定,并发下不稳定 |
注意一个措辞陷阱:面试官会说「HashMap 1.8 不是用 CAS + synchronized 保证线程安全的吗?」——这句话描述的是 ConcurrentHashMap 1.8,原生 HashMap 里没有任何同步原语(synchronized 只出现在 computeIfAbsent 之类的默认方法中,用于防止同一桶内递归更新,不是整体线程安全)。敢礼貌纠正比硬着头皮附和得分高:「这个描述其实是 ConcurrentHashMap 1.8 的实现,HashMap 本身一行同步代码都没有。」
五、ConcurrentHashMap 1.8 为什么放弃分段锁
原理。1.7 的 Segment 继承 ReentrantLock,默认 16 段,每段内部是一个「小 HashMap」(HashEntry[] + 链表)。这套设计解决了线程安全,但留下了四个结构性缺陷:
- 并发度被段数锁死:段数在构造时确定(默认 16),之后不能扩;16 核机器上 16 段就是并发上限,热点段一样要排队。
- 内存开销大:每个 Segment 都是一个带锁的独立容器,段多了浪费,段少了并发差,两头不讨好。
- 段内只有链表,没有树化:单个段内哈希碰撞严重时,查询退化成 O(n)——1.7 的 CHM 反而比 1.8 的 HashMap 更容易被碰撞打穿。
size()要全局停顿:先无锁试算两次,不一致就对所有 Segment 加锁再统计,高并发下这是个明显的抖动点。
1.8 的做法是把锁粒度从「段」压到「桶」:
// putVal 的核心分支(省略树化细节)
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))) // 空桶:CAS,无锁
break;
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f); // 正在扩容:帮着迁移,不阻塞
else {
synchronized (f) { // 非空桶:锁桶的首节点
if (tabAt(tab, i) == f) { /* 链表尾插或树插入 */ }
}
}
}
四个关键点:
tabAt用Unsafe.getObjectVolatile:保证读到的桶头是最新发布的对象,这是get完全无锁的前提。get全程不加锁,遇到ForwardingNode就用它的find去nextTable里找——扩容期间读也不阻塞。ForwardingNode的双重身份:hash = MOVED = -1。对读线程是「这个桶已迁走,去新表查」的路由牌;对写线程是「该桶已完成迁移」的标记,put命中它就不抢锁,直接helpTransfer。- 协作式扩容:扩容线程按
stride(MIN_TRANSFER_STRIDE,至少 16)从后往前认领桶区间,谁先来谁先领,sizeCtl的低 16 位记录参与线程数、负值表示正在扩容。这把一次 O(n) 的迁移摊给了所有写入线程,是「扩容不 STW」的关键。 size()从加锁统计变成分散累加:baseCount做基础计数,竞争时线程各自往CounterCell[]的一个槽里累加(LongAdder 思路),sumCount()求和。代价是读到的值可能瞬时不准——所以size()只能用于监控、日志、容量预估,绝不能拿来做业务判断(比如if (map.size() < 100) put(...),这个判断在并发下必然出错)。需要 long 范围就用mappingCount()。
追问:CHM 的迭代器为什么不会抛 CME? 它是弱一致性迭代器:迭代过程中能看到哪些元素不保证,但不会抛 ConcurrentModificationException,也不会读到半成品。反过来说,size() 与遍历结果之间也不保证一致——这条性质在「遍历做对账」的场景里必须显式说明,别让业务误以为拿到了快照。
六、computeIfAbsent 里的死锁:一个真实的生产级陷阱
现象。某个缓存工具类在低峰期运行正常,压测或流量上来后出现「少量请求永久挂住、线程池逐渐耗尽、重启恢复」。jstack 里能看到若干线程停在 ConcurrentHashMap.computeIfAbsent,且互相等待。
原理。1.8 的 computeIfAbsent 在桶为空时会先 CAS 放一个 ReservationNode(hash = RESERVED = -3)占位,再 synchronized(r) 执行 mappingFunction。于是有两个坑:
- 占位期间该桶是被锁住的。如果
mappingFunction里做的是远程调用、查库、或者对同一个 map 的同一个桶再写入,锁的持有时间就被放大到「一次 RPC」的量级,所有落在这个桶上的 key 全部排队。 - 递归更新同一个 map。同一线程因为
synchronized可重入,不会自锁,但会撞上占位节点、破坏桶结构或自旋;跨线程时则形成经典的循环等待——A 持有桶 1 的锁等 B 的结果,B 持有桶 2 的锁等 A,谁也退不出来。JDK 9 之后官方直接把这条路堵死:检测到递归更新就抛IllegalStateException: Recursive update。
排查。
jstack里找ConcurrentHashMap.computeIfAbsent帧,看它下面的业务方法是不是在做 IO 或二次写 map;- 看等待链是否成环(多个线程同帧互相等待)——与死锁不同,这里往往是「锁 + 远程调用」混合,
jstack未必报Found one Java-level deadlock,需要人肉看调用链; - 用 Arthas
watch该方法的耗时分布,或在mappingFunction里打点,确认慢在函数体内还是锁等待。
规范(比修复更重要):mappingFunction 只做纯内存计算。需要远程数据就「先查、再 put」,或者用 computeIfAbsent 只做粗粒度占位、真正的加载走双重检查 + 独立锁。同理,computeIfAbsent 返回值若为 null 不会写入,用「返回 null 表示不存在」做缓存会每次都穿透——空值要用哨兵对象占位。
七、key 设计与 fail-fast:两个最容易在代码里犯的错
1)key 的契约。HashMap 定位一个 key 靠两步:hash 相同 且 (== 或 equals)。所以:
- 只重写
hashCode不重写equals:两个「逻辑相等」的新对象hash相同但equals用引用比较为 false →put会挂在同一个桶的链上变成两个元素,get用新对象永远查不到。表现为「map 越来越大、get一直返回 null」。 - 只重写
equals不重写hashCode:两个相等对象落到不同桶,get也查不到。 - 可变对象做 key:
put之后改了参与hashCode的字段,桶位置就对不上了,这个 entry 变成永久孤儿——既是内存泄漏,也是「明明 put 过却 get 不到」的经典现场。key 必须是不可变对象(String、包装类型、record)。 - 数组做 key:
int[]的hashCode是身份哈希,两个内容相同的数组互不相等,要包成List或用Arrays.hashCode自定义包装类。
2)遍历中删除。HashMap 的迭代器是 fail-fast:modCount 在结构性修改时自增,迭代器每次 next() 比对 expectedModCount,不一致立刻抛 ConcurrentModificationException。这就是快手面经里那道「迭代中调用 remove() 会发生什么」的答案。正确姿势三种:
// ① 用迭代器自己的 remove(唯一安全的边遍历边删)
Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
if (it.next().getValue() == 0) it.remove();
}
// ② JDK 8 的 removeIf(内部仍是 iterator.remove)
map.entrySet().removeIf(e -> e.getValue() == 0);
// ③ 先收集 key,再批量删(语义最清晰,适合删除条件复杂时)
List<String> toRemove = map.entrySet().stream()
.filter(e -> e.getValue() == 0).map(Map.Entry::getKey).collect(Collectors.toList());
toRemove.forEach(map::remove);
补一句区分:ConcurrentHashMap 的迭代器是弱一致的,不会抛 CME,但也不保证看到全部元素——所以「CHM 里删元素不用管」是另一个常见误解。
八、场景题:内存装不下时,集合还能怎么用
这类题是集合簇的「压轴」,考的是把容器当工具而不是当答案。美团一面原题:两个超大集合,各自内部不重复,之间存在重复,内存装不下,怎么找重复元素?
原理。本质是「在有限内存下做去重/求交」。三条路,成本与精度不同:
| 方案 | 做法 | 内存 | 精度 | 适用 |
|---|---|---|---|---|
| 分桶哈希(哈希分片) | 按 hash % N 把两个集合分别切成 N 个小文件,同余数的小文件必然包含全部潜在重复;逐对加载进 HashSet 求交 | 单桶可控 = 总量/N | 精确 | 首选,工程上最稳 |
| 布隆过滤器预筛 | 先把 A 灌进布隆过滤器,再扫 B,命中的再落盘做精确校验 | 极省(bit 级) | 有假阳性、无假阴性 | 只想要「大概率重复」或做前置过滤 |
| 外部排序归并 | 两个集合各自排序落盘,双指针归并找相同 | 磁盘为主 | 精确 | 数据本身有序或已有排序设施 |
同一套思路的另一道变体:小内存机器上有个超大日志文件,只记录 IP,找访问次数最多的 IP。答案是「分桶 + 局部 HashMap + 小顶堆」:按 IP 哈希切 N 份 → 每份单独加载进 HashMap<String,Integer> 计数,取该份 Top K → 汇总 N 份的 Top K 建大小为 K 的小顶堆。真实生产里如果允许近似,Count-Min Sketch 更省内存,代价是计数偏高。
选型口径:答题时先说「内存上限是多少、是否要求精确、能否多轮扫描」这三个前提,再给方案。上来就说「用 HashMap 统计」的,等于承认没做过大数据量。
九、把容器能力补全:ArrayList、LinkedHashMap 与 LRU
集合簇的追问往往会从 HashMap 滑到相邻容器,几个必答点:
ArrayList扩容是 1.5 倍(oldCapacity + (oldCapacity >> 1)),不是 2 倍;HashMap才是 2 倍。1.5 倍是为了在「扩容次数」与「空间浪费」之间取平衡,且便于复用已释放的连续空间。ArrayListvsLinkedList:教科书说「频繁插入删除用 LinkedList」,实际几乎总是错的——LinkedList每个节点额外两个引用(内存放大 3 倍以上)、内存不连续导致 CPU 缓存命中率低,中间插入还要先 O(n) 定位。真实结论:默认用ArrayList,只有确实拿到节点引用、且在头部做大量插入时才考虑LinkedList。LinkedHashMap保序:accessOrder=false保插入序,true保访问序(每次get把节点移到队尾),这是 LRU 的实现基础;覆写removeEldestEntry返回size() > capacity即得一个线程不安全但极简的 LRU。- 手撕 LRU(LeetCode 146):
HashMap存 key→节点 + 双向链表维护顺序,get/put都要把节点移到头部,超容量删尾节点。面试重点不是写出来,而是主动声明「这个实现非线程安全,并发场景要加锁或用 Caffeine」。
三层追问链自测
把上面的内容压成三条链,能顺着答完三层就算过关:
链一(源码层):put 流程 → 为什么 (n-1) & hash → 为什么 hash 要 >>> 16 扰动 → 树化阈值 8 的泊松依据 → 为什么退化是 6 → 为什么还要 table.length >= 64 → 扩容时高低位拆分怎么保持顺序。
链二(并发层):HashMap 线程安全吗 → 1.7 头插为什么会成环(能画出 T1/T2 交错) → 1.8 尾插后还安全吗(列举四类丢失) → 那 CHM 1.8 怎么做的 → 为什么放弃分段锁 → 扩容时其他线程在干什么(ForwardingNode/stride) → size() 为什么不准 → computeIfAbsent 有什么坑。
链三(工程层):本地缓存用 HashMap 出过什么问题 → 怎么定位到成环(top -Hp + jstack + MAT) → 修完怎么防复发(不可变发布 / CHM / 编码规约) → 千万级数据找重复怎么设计(分桶/布隆/外部排序) → 为什么不能拿 size() 做限流判断。
一句话总结
HashMap 的每个魔法数字背后都是一个权衡:8 是「泊松分布的极低概率」与「树化内存代价」的平衡,6 是给这个平衡加的防抖缓冲,64 是「扩容比树化更便宜」的判断线,0.75 是空间与时间的折中。而 ConcurrentHashMap 的演进史,本质是「锁粒度一路变细、竞争一路分散」的历史:分段锁 → 桶级锁,全局计数 → 分散计数,独占扩容 → 协作扩容。能把这四句话讲成一条因果链,这一簇题就不再需要背了。
下一篇预告:第 9 篇写「信创国产化迁移」——聚焦达梦数据库:从 MySQL/Oracle 迁达梦的方言差异(分页、序列、大小写敏感、保留字)、SQL 兼容模式怎么选,到 WebLogic/TongWeb 中间件适配、CentOS→麒麟/UOS 的操作系统层迁移、JVM 与连接池的坑,最后讲金融信创验收怎么举证。视角是迁移实操 + 验收清单,不重复第 3 篇的 MySQL 原理。
332



被折叠的 条评论
为什么被折叠?



