Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

2026金九银十Java后端与AI岗面试攻略:并发、场景题与RAG实战 在技术面试持续演进的当下,Java后端岗位依然是企业级应用的中流砥柱,但面试考察重心已从单纯八股文转向底层原理深度、高并发场景设计以及AI应用落地能力。理解并发编程中的锁机制、线程池调优与JVM排查,是区分候选人的关键分水岭;掌握Redis缓存一致性、分布式场景下的幂等与异步处理,则是应对系统设计的必备技能。随着大模型技术普及,Java工程师更需要理解RAG检索增强生成、Prompt设计、Function Calling等AI应用链路,并将这些能力融入实际业务系统。无论是构建智能文档助手、客服工单系统,还是 阅读详情

本文是「2026 Java 后端面试连载」第 8 篇。前 7 篇已覆盖 Java 并发、Redis、MySQL、JVM 调优、Spring 原理、消息队列与分布式事务、高并发场景设计,链接见文末。本篇回到 Java 基础层,只写集合容器源码这一条线——与第 1 篇的线程池、AQS、锁升级严格不重叠。

题目来源说明

本文题目来自两类公开材料,不是编的:

  1. 公开招聘 JD 样本:基于 38 期公开招聘 JD 样本统计(BOSS 直聘、拉勾、猎聘等平台在招岗位),「JVM / 并发 / Java 基础」平均提及率 61%,位列第 5;其中「HashMap 与集合容器」考点在 30 期样本中出现、去重后 38 个题变体,在 29 个考点簇中排名第 8——它几乎是每份 JD 里「Java 基础扎实」这句话的唯一可验证抓手。
  2. 公开面经:牛客、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_CAPACITY162 的幂,使 (n-1) & hash 等价于取模但更快;16 是「小到不浪费、大到不易碰撞」的经验值
负载因子 DEFAULT_LOAD_FACTOR0.75空间与时间的折中;0.75 下桶内节点数服从 λ≈0.5 的泊松分布,碰撞概率已被压到很低
树化阈值 TREEIFY_THRESHOLD8λ=0.5 时桶内 8 个节点的概率约 6×10⁻⁸,树化是防御哈希碰撞攻击的兜底,不是常规路径
退化阈值 UNTREEIFY_THRESHOLD6与 8 之间留 7 作缓冲带,避免桶在 7↔8 抖动时反复树化/退化(两者都是 O(n) 操作)
最小树化容量 MIN_TREEIFY_CAPACITY64表还小时优先扩容而不是树化——扩容能把碰撞节点分散开,成本更低
最大容量 MAXIMUM_CAPACITY1<<30int 正数范围内最大的 2 的幂;再大 (n-1) & hash 也不会更分散

速查表二:JDK 7 与 JDK 8 的 HashMap / CHM 差异

维度HashMap 1.7HashMap 1.8ConcurrentHashMap 1.7ConcurrentHashMap 1.8
数据结构数组 + 链表数组 + 链表 + 红黑树Segment[] + HashEntry[] + 链表Node[] + 链表 + 红黑树
插入方式头插尾插头插(HashEntry.next 为 final)尾插
并发控制无无分段锁(Segment 继承 ReentrantLock)空桶 CAS + 非空桶 synchronized 锁首节点
并发度——上限 = 段数(默认 16)约等于桶数量
扩容逐桶 rehash,头插导致逆序高低位拆分 (e.hash & oldCap),保持相对顺序段内扩容多线程协作迁移 + ForwardingNode 转发
size 统计直接返回 size 字段直接返回 size 字段先无锁试算两次,不一致再加锁全段统计baseCount + CounterCell[] 分散累加
是否允许 nullkey/value 都允许key/value 都允许都不允许都不允许

速查表三:业务里选哪个 Map

场景选择一句话理由
单线程/方法内临时聚合HashMap无同步开销,最快
需要按插入序或访问序遍历LinkedHashMap额外双向链表维持顺序,LRU 就靠 accessOrder=true
需要按 key 排序/范围查询TreeMap红黑树,subMap/floorKey 只有它有
多线程读写同一个 MapConcurrentHashMap桶级锁 + 无锁读,唯一的生产答案
读多写极少、且要求强一致快照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;
}

三个容易被追问的细节:

  1. 为什么 index = (n-1) & hash 而不是 hash % n:n 是 2 的幂时两者等价,但位运算没有除法指令的延迟;这也是容量必须强制为 2 的幂的原因(tableSizeFor 把任意初始容量向上取到 2 的幂)。
  2. 为什么 hash 要先扰动:h ^ (h >>> 16) 把高 16 位混进低 16 位。因为 (n-1) & hash 只用到低位,若直接用 hashCode(),高位差异全被丢弃,一批只在高位不同的 key 会挤进同一个桶。
  3. treeifyBin 不等于必然树化:进方法后第一件事是判断 tab.length < MIN_TREEIFY_CAPACITY(64),成立就 resize() 返回。所以「链表到 8 一定变红黑树」是错的——表长不足 64 时只会扩容。

二、树化阈值 8 的数学依据与 6 的缓冲意义

原理。HashMap 源码注释里直接给了泊松分布表,这是全网最爱考、也最容易答成「背数字」的一题。要在数学上讲清楚三件事:

第一,8 的前提是理想哈希。 负载因子 0.75、容量 n 的表中,任一桶内节点数近似服从参数 λ≈0.5 的泊松分布,源码注释给出的概率是:

桶内节点数概率
00.60653066
10.30326533
20.07581633
30.01263606
40.00157952
50.00015795
60.00001316
70.00000094
80.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」的处置顺序:

  1. top -Hp <pid> 找出高 CPU 线程,printf '%x' 转十六进制,jstack <pid> | grep -A 30 <nid> 看栈顶;若多条线程都停在 java.util.HashMap.getEntry,基本可判定成环(不是死锁,所以看不到 BLOCKED)。
  2. jmap -dump 拿堆,MAT 里看该 HashMap 的某个桶,节点 next 指针成环即为铁证;也可搜 HashMap$Entry 数量异常。
  3. 根因不在 HashMap,在使用方式:这类现场 99% 是「本地缓存」被多个业务线程无锁写(private static Map cache = new HashMap()),并发扩容时踩上。
  4. 修复优先级:① 换 ConcurrentHashMap(根治);② 若只是启动时构建、之后只读,用 Collections.unmodifiableMap 或 Map.copyOf 在发布前冻结,并加 final;③ 退一步用 Collections.synchronizedMap,但它是全表锁,只在极低并发下可接受。

选型。这一题真正考的是「什么时候可以放心用 HashMap」:要么单线程独占,要么构建完成后只读。只要存在「运行期并发写」,答案就是 ConcurrentHashMap,不是「加个 synchronized 包一下」——包一层就等于把并发度降到 1。

四、1.8 改成尾插之后,为什么依然线程不安全

这是本簇最容易被答错的追问。很多人的答案是「尾插不会成环,所以 1.8 的 HashMap 是线程安全的」——错。尾插只消除了「成环」这一种最恶劣的表现,其他并发问题一个都没解决:

并发场景后果原因
两个线程同时往空桶 put一个元素被覆盖丢失1.8 用 tab[i] = newNode(...) 直接赋值,不是 CAS,无原子性
两个线程同时 ++sizesize 偏小,进而扩容时机偏晚,链越来越长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[] + 链表)。这套设计解决了线程安全,但留下了四个结构性缺陷:

  1. 并发度被段数锁死:段数在构造时确定(默认 16),之后不能扩;16 核机器上 16 段就是并发上限,热点段一样要排队。
  2. 内存开销大:每个 Segment 都是一个带锁的独立容器,段多了浪费,段少了并发差,两头不讨好。
  3. 段内只有链表,没有树化:单个段内哈希碰撞严重时,查询退化成 O(n)——1.7 的 CHM 反而比 1.8 的 HashMap 更容易被碰撞打穿。
  4. 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。于是有两个坑:

  1. 占位期间该桶是被锁住的。如果 mappingFunction 里做的是远程调用、查库、或者对同一个 map 的同一个桶再写入,锁的持有时间就被放大到「一次 RPC」的量级,所有落在这个桶上的 key 全部排队。
  2. 递归更新同一个 map。同一线程因为 synchronized 可重入,不会自锁,但会撞上占位节点、破坏桶结构或自旋;跨线程时则形成经典的循环等待——A 持有桶 1 的锁等 B 的结果,B 持有桶 2 的锁等 A,谁也退不出来。JDK 9 之后官方直接把这条路堵死:检测到递归更新就抛 IllegalStateException: Recursive update。

排查。

  1. jstack 里找 ConcurrentHashMap.computeIfAbsent 帧,看它下面的业务方法是不是在做 IO 或二次写 map;
  2. 看等待链是否成环(多个线程同帧互相等待)——与死锁不同,这里往往是「锁 + 远程调用」混合,jstack 未必报 Found one Java-level deadlock,需要人肉看调用链;
  3. 用 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 倍是为了在「扩容次数」与「空间浪费」之间取平衡,且便于复用已释放的连续空间。
  • ArrayList vs LinkedList:教科书说「频繁插入删除用 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 原理。

SpringBoot+Vue+MySQL 高校学科竞赛平台 完整可运行版(源码+文档) 本项目基于SpringBoot+Vue+MySQL构建高校学科竞赛管理平台,覆盖学生、教师、领队教师、管理员四大角色,实现竞赛发布、报名、刷题、评分、公示等全流程闭环管理。系统架构清晰,技术主流,配套完整源码、数据库脚本、万字论文、开题报告、答辩PPT及部署文档,支持一键运行,适用于毕业设计、课程设计及院系二次开发,真正实现“开箱即用”。 阅读详情

相关推荐

保姆级教程:用OpenCV和MediaPipe在Python里实现实时手势识别(附完整代码)

本文提供了一份详细的Python教程,教你如何使用OpenCV和MediaPipe实现实时手势识别系统。从环境配置、手部关键点检测到手势分类算法,逐步讲解如何构建高精度手势识别应用,适用于智能家居控制、PPT操作等场景。教程包含完整代码示例和性能优化技巧,特别适合计算机视觉初学者和开发者实践。

weixin_28677005的博客 332

2026 Java后端AI岗位面试攻略:并发JVM与大模型RAG实战

在AI与大模型快速融入企业级应用的背景下,Java后端工程师的面试要求正发生深刻变化。同步掌握Java并发、JVM底层原理与Spring生态,并熟悉RAG、Agent、向量数据库等AI工程化技术,已成为高薪岗位的标配。本文结合真实面试复盘,系统梳理了2026年Java(AI)岗的备考路径、高频考点、场景题应对策略及谈薪技巧,帮助开发者构建从理论到落地的完整能力闭环。

weixin_34302561的博客 392

MySQL表名大小写敏感问题终极解决:lower_case_table_names=1不生效的3个隐藏坑

本文深入剖析了MySQL表名大小写敏感问题中,设置lower_case_table_names=1参数不生效的三个核心原因。关键在于理解该参数只能在数据库初始化前设置,并需排查配置文件优先级与正确停止服务的顺序。文章提供了从Windows迁移到Linux的完整避坑指南与验证方法,帮助DBA和开发者彻底解决这一跨平台兼容性难题。

weixin_29229055的博客 395

2026年Java面试趋势与深度技术解析

Java作为企业级开发的主流语言,其技术栈的深度和广度一直是面试考察的重点。随着分布式系统和云原生技术的普及,Java面试的考察维度正在从基础八股文向动态八股和深度原理演进。理解JVM内存模型、Spring框架的循环依赖机制、以及分布式场景下的CAP理论取舍,成为工程师必备的核心能力。在实际应用中,诸如Redis+Lua实现库存防超卖、K8s环境下JVM参数优化等场景题,不仅考察技术原理,更注重工程实践能力。掌握这些技术不仅能提升面试通过率,更能为构建高可用、高性能的系统打下坚实基础。

weixin_34166472的博客 447

system_stm32f10x.c文件分析

配置系统时钟(包括系统时钟源、锁相环(PLL)倍频系数、高级高性能总线(AHB)/ 高级外设总线(APBx)预分频器以及闪存相关设置)。该函数在系统复位后的启动阶段被调用,且调用时机早于跳转到主程序之前。

Jia shuheng的博客 605

DC-DC降压转换器PCB设计全解析

DC-DC降压转换器的PCB布局设计直接影响电源效率、电磁干扰、稳定性和热性能。关键设计因素包括:优化旁路电容布局以降低环路电感,合理规划大电流走线宽度,根据开关频率选择元件尺寸,控制热阻(RθJA)确保散热效率,以及精确布置反馈补偿网络。设计中需特别注意高di/dt路径的场效应管布线,采用紧凑布局减少寄生电感,并通过多层板结构和散热过孔优化热管理。无论是外置还是集成式场效应管设计,都需要平衡电气性能与散热需求,遵循IPC标准规范,才能实现高效可靠的电源转换方案。

一只豌豆象的博客 417

2026 Java面试突击方案:八股+场景题+AI大模型

在Java后端开发中,并发编程、Spring容器与分布式系统始终是核心能力。理解线程池参数调优、synchronized锁升级、Spring三级缓存解决循环依赖的原理,以及Redis分布式锁的选型,不仅是应对技术面试的基础,也是构建高可用服务的工程实践。随着AI技术落地,RAG检索增强生成、Spring AI集成和Prompt工程逐渐成为后端开发的新场景需求。面对2026年求职季,面试更强调从基础原理到场景设计的综合能力,需要系统化梳理高频考点与答题方法论。本文提供一条从基础八股到场景题,再到AI大模型的短

weixin_33755557的博客 297

基于STM32设计的猪舍养殖的监控系统_325

本课题基于STM32单片机,设计一款能够实时监测猪舍环境的智能监控系统。该系统能够通过温湿度、空气质量、光照强度等传感器实时监测猪舍的环境,并能够通过自动化控制设备(如风扇、照明灯、消毒喷雾等)调节环境参数,确保养殖环境的适宜性。同时,系统还支持通过ESP8266模块实现数据上传与远程控制,使养殖管理者能够通过手机APP或计算机远程监控和控制猪舍环境。

409

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 311

微观交通流仿真软件:SUMO (Simulation of Urban MObility)_(8).仿真场景创建与编辑

总结文件()包含了仿真过程中的总体统计信息,如车辆生成数、平均速度等。加载总结文件使用Python的提取关键信息通过以上步骤,可以使用SUMO及其相关工具和库创建和编辑交通仿真场景。无论是手动创建、使用工具转换现有数据,还是通过Python脚本自动生成,SUMO都提供了丰富的功能来满足不同需求。此外,Traci库允许在仿真过程中动态调整交通场景,从而实现更精细的控制和优化。最后,通过对输出文件的分析,可以评估仿真结果并进行进一步的改进。

kkchenjj的博客 1273

华为交换机系统软件升级和安全漏洞修复教程

在华为交换机国网可以查询到华为交换机官方电话:400-822-9999,通过下命令查询出需要升级的交换机软件版本和补丁版本号发给华为,获取新的升级系统软件和补丁以及升级教程。下面是我升级华为交换机总结的教程,作为参考。...

星如雨落 2965

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 339

uniapp开发小程序保存图片权限获取失败一直走fail?本地能保存,线上版就不行! 原来是这个问题!

通过这次经历,我发现线上版小程序和开发版、体验版的权限控制差异较大。如果你也遇到类似的问题,首先要检查是否已勾选“采集用户隐私”,并确保在提交审核时配置了隐私条款。这个设置非常关键,避免像我一样浪费了不少时间和版本。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1080

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 619

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 239

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 251

spdlog 同步日志库使用详解

spdlog是一个轻量级 C++ 日志库,支持同步日志、异步日志、多线程日志、日志文件轮转和自定义日志格式。对于嵌入式 Linux 应用开发,我建议先使用。它可以帮我们完成:日志级别过滤。时间戳和线程 ID 输出。日志格式化。终端和文件输出。多线程安全写入。日志文件按大小或时间轮转。我们不需要自己实现互斥锁、文件写入、日志格式化和轮转等底层功能。

zengjiajun2006的博客 1124

JavaSE通关手册:数据类型与变量

代码无需额外处理,编译时编译器自动完成转换。

xys_678的博客 236

IDEA 简介:从零认识 IntelliJ IDEA

IDEA 全称,是由 JetBrains 公司开发的一款主流 Java 集成开发环境(IDE)。它集代码编辑、编译、调试、测试、版本控制、构建管理等功能于一体,被大量 Java 开发者视为日常开发的首选工具。所谓 IDE(Integrated Development Environment,集成开发环境),就是把写代码所需的各类工具整合到同一个界面中。相比只用文本编辑器加命令行编译,IDE 能显著减少重复操作,让开发者把精力集中在业务逻辑上。

ztI10的博客 190

Docker部署linkding:HTTPS与数据备份

部署私人书签库,除了让页面能够打开,还需要考虑几个实际问题:重建容器后数据是否保留、登录和保存是否正常、升级前怎样备份,以及出现 502 或 CSRF 错误时从哪里检查。本文使用 Docker Compose 部署 linkding,采用默认 SQLite 数据库,通过 Caddy 提供 HTTPS,并完成账户创建、数据持久化验证和备份。如果重建后账户或书签消失,应先检查是否换了项目目录、改了挂载路径,或者启动了另一套实例,不要急着重新初始化。遇到权限问题,应根据日志确认具体目录和运行用户,再调整权限。

tedcloud123的博客 196

动态代理两大流派:JDK 代理与子类代理

业务类想加日志,最直白的写法是侵入式修改: 问题很明显:每个方法都要改一遍,改一个业务要动十处。代理模式的解法是:调用方不直接依赖 ,而是依赖一个代理对象。代理对象长得跟目标一模一样,调用它 → 代理先执行增强逻辑 → 再转调真实对象。 关键在于:代理对象的类型是哪来的?这就是"动态"二字的含义:代理类在运行时才诞生。两个角色: 承载增强逻辑, 负责生成代理类。 组装代理并调用: 输出: 业务代码 一行没动,增强逻辑全在 里。这就是 AOP 的味道。 内部四步: 第 2 步 内部:先查 (同一个接口

Android的专栏 665

C++20协程怎么运行?原理与三大核心组件深度剖析

C++20协程是轻量级的无栈状态机,通过co_await、co_yield、co_return实现挂起与恢复,由Promise、协程句柄和Awaitable三大组件协同工作。协程与线程互补,适用于高效管理大量并发I/O任务,显著降低上下文切换开销。其核心在于编译器生成的状态机机制,需配合库(如cppcoro)使用。掌握Promise控制逻辑、句柄生命周期管理及Awaitable语义,是构建高性能异步程序的基础。

Lucis__的博客 337

c++ explicit关键字详解

explicit。

拒绝AI文,努力在AI时代写出感动人心的好文章 170

TRingBuffer两端都能增删(快递站版)

TRingBuffer 是一个支持两端增删、下标访问且容量动态增长的环形双端队列。它通过无符号索引的永不归零设计,利用减法自动模运算实现空满判断与元素计数,避免了传统环形缓冲浪费格子的问题。内部以票号(索引)标记首尾,扩容时重排元素为连续存储,保证 O(1) 操作与高缓存效率。虽不线程安全,但其高效性使其成为游戏开发中事件队列、命令缓冲等场景的理想选择。

u013768914的博客 315
上一篇: 高并发场景设计高频面试题全解:秒杀库存、千万 QPS 限领与宕机对账(2026 招聘 JD 真题复盘)
下一篇: SELinux 拦截 sshd 绑定 1022 端口:问题整理
蒙眼过河
博客等级 码龄17年 28粉丝 107原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值