面灵AI→

快手日常一面:面向对象、ConcurrentHashMap 与 AQS 三十二问

轮次
一面
时间
2026-09
来源
牛客网

《面试题目》

面试时长 1 小时。原帖记录者只记得八股部分,项目细节已忘。

一、面向对象(设计与抽象)

  1. 面向对象怎么理解?
  2. 面向对象和面向过程的区别是什么?
  3. 怎么理解「以对象为核心」?
  4. 举一个现实中面向对象、面向过程的例子。
  5. 多态是怎么实现的?
  6. 抽象和继承是一回事吗?
  7. 模板方法模式是什么?
  8. 继承和抽象到底有什么区别?
  9. 继承是自上而下的设计吗?
  10. 抽象是自上而下的设计吗?
  11. 设计一台汽车,用继承还是抽象?是自上而下还是自下而上?

二、集合与并发容器

  1. 直播间观众要根据用户 id 查用户信息,用什么集合?
  2. 讲一下 ConcurrentHashMap 的并发问题。
  3. HashMap 和 ConcurrentHashMap 的主要区别?
  4. HashMap 和 ConcurrentHashMap 在数据结构上的区别?
  5. ConcurrentHashMap 实现线程安全还有哪些细节?
  6. 什么时候用分段锁、什么时候用 CAS + synchronized?
  7. ConcurrentHashMap 的并发循环(迭代遍历)要注意什么?
  8. 并发成环问题是什么?

三、锁与线程工具

  1. synchronized 锁的细节。
  2. 讲一下 synchronized 的锁升级过程。
  3. AQS 锁和 synchronized 的区别?
  4. 公平锁和非公平锁的区别?
  5. 可重入锁和不可重入锁的区别?
  6. synchronized 可重入的原理是什么?
  7. AQS 是怎么阻塞和唤醒线程的?
  8. AQS 的 CLH 队列为什么是双向队列?
  9. ThreadLocal 是什么?
  10. ThreadLocal 的内存泄漏讲一下。
  11. 请求上下文怎么透传?

四、项目与存储

  1. 你项目(码试官 AI 面试平台)的完整数据链路是怎样的?
  2. MongoDB 的数据过期机制是怎么做的?

《参考解析》

面向对象与面向过程的分界不在语法,而在「谁负责变化」。 面向过程把问题拆成步骤序列,数据在函数之间流转,变化集中在函数内部;面向对象把问题拆成一组有状态、有行为的对象,变化被封装在对象边界内。判断一段代码是不是真的面向对象,看一条:改动一个需求时,是改了很多函数的同几行,还是改了一个类的实现。 「以对象为核心」的意思是:以「谁在承担这个职责」为第一视角组织代码,而不是以「数据怎么流」为第一视角。现实例子里最常被接受的是 ATM:面向过程写「插卡 → 验密 → 查余额 → 出钞」一串流程;面向对象写「客户、账户、银行卡、取款机」几个对象各自负责,取款机只知道「向账户请求扣款」,账户怎么扣它不管。面试里举这个例子比说「动物会叫」更能证明你真的想清楚了。

多态的实现是「编译期定签名、运行期找实现」。 Java 里靠方法表(vtable):子类重写的方法在方法表里指向自己的实现,父类引用调用时按对象的实际类型查表。三个必要条件缺一不可——继承(或实现接口)、重写、父类引用指向子类对象。要能区分重载(编译期静态分派,看参数静态类型)和重写(运行期动态分派,看对象实际类型),这是这组题最容易被追问穿的地方。

抽象与继承不是一回事:继承是「拿到」,抽象是「规定」。 继承解决代码复用与类型归属(is-a),它天然是自上而下的——先有一个父类,再派生出更具体的子类。抽象解决的是「只关心共同契约、不关心具体实现」,它既可以自上而下(先定义接口再分别实现),也可以自下而上(先写了三个类,发现共同点,抽出接口)。所以第 8、9、10 题的正确答案是:继承是自上而下的;抽象两个方向都行,实际工程里自下而上抽取更常见。

「设计一台汽车用继承还是抽象」考的是你分不分得清「是什么」和「能做什么」。 车不是一个而是很多种(轿车、卡车、电车),它们共享的是一套能力和部件,所以正确做法是抽象:定义 Vehicle 的能力契约(能跑、能刹、能载),用组合把发动机、变速箱作为部件装进去,具体车型实现契约。继承只在「确实存在稳定的一般—特殊关系、且父类不会随子类频繁改动」时才用。判断继承是否用错的标准是里氏替换:如果子类必须抛异常或空实现来「不遵守」父类行为,那就不该用继承。汽车题的标准答法收尾一句:用抽象定义契约、用组合装配差异、继承留给真正的一般—特殊。

模板方法模式是「父类定骨架、子类填步骤」。 父类的 final 方法里写死流程顺序(比如「校验 → 组装 → 执行 → 回写」),把可变的几步抽成 protected abstract 方法交给子类。它和继承的关系就在这里:它是继承最正当的用法之一,因为骨架是稳定的、变化点是被明确圈定的。举项目里的例子(比如不同渠道的支付流程、不同模型的调用流程)比背定义更有说服力。

「直播间按用户 id 查用户信息」的答案取决于读多写少还是写多读少。 单机高频读、只读或极少写,用 ConcurrentHashMap;要保证顺序或需要范围查询,用 ConcurrentSkipListMap;跨进程、要持久化,那不是集合问题,是缓存(Redis)或数据库问题。作答时把「容量多大、是否会被清理、有没有淘汰需求」问清楚,比直接答一个类名更像工程师。

ConcurrentHashMap 的演进是这道题的主线:从分段锁到 CAS + synchronized。 JDK 7 是 Segment 数组(默认 16 段),每段一把 ReentrantLock,代价是并发度固定、内存开销大。JDK 8 改成一个 Node 数组 + 链表/红黑树,锁的粒度降到「桶的头节点」:空桶用 CAS 直接插入,非空桶 synchronized 锁住头节点再挂链,扩容用多线程协助迁移(ForwardingNode 标记 + 每个线程领一段 stride 迁移)。和 HashMap 的区别就集中在这几处:不允许 null 键值(并发下无法区分「不存在」和「值为 null」)、size 用 baseCount + CounterCell[] 分散计数而不是单个 size 字段、扩容支持并发协助、以及提供了 putIfAbsent / computeIfAbsent 这类原子复合操作。

「什么时候分段锁、什么时候 CAS + synchronized」要答成「冲突概率的取舍」。 冲突极低(比如只写一次、之后全读,或写的 key 分布很散)用 CAS,无锁、无上下文切换,失败重试代价小;冲突中等用「CAS 尝试 + 失败退化为 synchronized」——这正是 CHM 的策略,因为高冲突下 CAS 会空转烧 CPU,而 synchronized 在 JDK 6 之后有偏向锁/轻量级锁,短临界区的开销已经很低。分段锁适合「能天然切分成互不相干的片、且片数足够」的场景,代价是并发度被写死。

CHM 的迭代遍历是弱一致的。 iterator() 拿到的是「遍历开始那一刻的近似视图」:遍历过程中别的线程增删不会抛 ConcurrentModificationException,也不会阻塞,但你看到的不一定是某一瞬间的完整快照(可能看到新插入的元素,也可能看不到)。所以 size() 只能当估算用(它是分散计数的和,并发下不精确),需要精确数量必须自己加锁或用 mappingCount()(返回 long,语义上仍是估算)。这一点和 HashMap 的 fail-fast 正好相反,是必答的对比点。

并发成环是 HashMap 在 JDK 7 及以前并发扩容时的经典 bug。 旧实现扩容时把链表节点用头插法搬到新数组,两个线程同时扩容时,一个线程可能读到另一个线程已经反转过的链表,指针互相指向,形成环形链表;之后任何一次 get 落到这个桶就会死循环、CPU 打满。JDK 8 改成了尾插(保持相对顺序)+ 红黑树化 + 协助扩容标记,成环问题不再出现,但并发写仍然会丢数据、size 不准,所以 HashMap 依然不是线程安全的。这题的正确收尾是:成环是 JDK 7 的特有 bug,JDK 8 修掉了,但「HashMap 不能并发写」这条结论没变。

synchronized 的锁升级是「按竞争程度逐级加码」。 无锁 → 偏向锁(第一个线程拿到后把线程 id 记在对象头 Mark Word,之后同一线程进入不用 CAS;有竞争就撤销)→ 轻量级锁(CAS 把 Mark Word 指向栈上的 Lock Record,失败则自旋)→ 重量级锁(自旋失败后向 OS 申请 monitor,线程进入阻塞队列,涉及用户态/内核态切换)。升级不可逆,这是为了省掉反复判断的成本。JDK 15 之后偏向锁默认关闭并最终废弃,理由是它的撤销成本在现代应用里抵消了收益——这一点能说出来,说明你不是只背了八股。

AQS 与 synchronized 的差别在「管什么、谁来管」。 synchronized 是 JVM 层面的关键字,管的是临界区互斥,锁的获取与释放由字节码 monitorenter/exit 保证,异常时自动释放。AQS 是 JDK 层面的框架,用 volatile int state + CAS 实现同步状态,用 CLH 变体的双向队列管理等待线程,ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock 都建在它上面。AQS 的优势是可中断、可超时、可公平、可条件变量(多个 Condition)、可读写分离;synchronized 的优势是简单、不会忘记释放。

公平与非公平的差别只在「排队的人有没有优先权」。 公平锁在 tryAcquire 里先检查队列有没有前驱,有就乖乖排队(hasQueuedPredecessors),吞吐低但不会饿死;非公平锁上来就 CAS 抢,抢不到再排队,允许插队,吞吐高但可能让队列里的线程长时间等。ReentrantLock 默认非公平,synchronized 也是非公平的。

可重入的实现是「记住是谁持有、持有几次」。 AQS 的 state 同时承担这两个职责:为 0 表示未被持有,线程 A 拿到后置 1 并记下 exclusiveOwnerThread,A 再次加锁时发现持有者是自己就把 state 加到 2,解锁时减 1,减到 0 才真正释放并唤醒后继。synchronized 同理,靠对象头里的锁记录与 monitor 的 _recursions 计数。不可重入锁(比如朴素的 AtomicBoolean 实现)在同一线程二次进入时会自己把自己锁死。

AQS 的阻塞与唤醒靠 LockSupport.park/unpark。 线程入队后调用 park 挂起(不响应中断的版本是 park(),parkNanos 带超时),前驱释放锁时 unparkSuccessor 唤醒队首的有效节点。用 LockSupport 而不是 wait/notify 的原因是它不需要先获得 monitor、能以线程为单位精确唤醒、还允许「先 unpark 再 park」(许可机制),避免了 notify 丢失唤醒的经典问题。

CLH 队列必须是双向的,因为 AQS 需要「从后往前找真正能唤醒的节点」。 入队是尾插(靠 CAS 保证原子),但唤醒时队首可能已经取消(超时、中断),必须向前回溯跳过 CANCELLED 节点;同时节点取消时要能把自己从链上摘掉(prev.next = next),单链表做不到 O(1) 摘除。这就是双向链表的两个刚性需求。原始 CLH 是单链自旋锁,AQS 改成双向 + 阻塞,所以常被称作「CLH 变体」。

ThreadLocal 的本质是「线程自己持有的一张 map」。 每个 Thread 里有一个 ThreadLocalMap,key 是 ThreadLocal 对象(弱引用),value 是值(强引用)。用它存请求上下文(traceId、用户身份、租户)最合适,因为它天然按线程隔离、不需要传参。

内存泄漏的成因是 key 弱引用、value 强引用造成的错配。 ThreadLocal 对象被回收后,Entry 的 key 变成 null,但 value 还被 Entry 强引用着,而 Entry 又挂在线程的 map 上;线程池里的线程活得很久,这些 value 就一直不释放。get/set 时会顺手清理一部分 stale entry,但不保证清干净。所以规范是 try/finally 里 remove()。另外要注意 InheritableThreadLocal 在线程池里会失效(线程是复用的,只在创建时继承一次),需要跨线程传递就用阿里的 TransmittableThreadLocal 或显式传参。

请求上下文透传有三条路,越往后越可靠。 单线程同步调用靠 ThreadLocal;线程池里靠包装 Runnable/Callable 在提交时快照、执行时恢复(TTL 的做法);异步/响应式链路靠把上下文放进 Context 对象随调用链显式传递(Reactor 的 contextWrite)。微服务之间还要跨进程:traceId 放进 HTTP header / MQ 消息头,由拦截器在入口处取出重新绑定。这题答完补一句「隐式透传最怕的是泄漏到下一个请求」,正好把 ThreadLocal 的清理串起来。

项目数据链路的答法要能一眼看出边界。 按「接入 → 编排 → 模型 → 存储 → 回放」讲:客户端建立长连接(websocket/SSE),网关鉴权并分配会话;编排层维护面试状态机与上下文,按轮次组装 prompt 调模型;模型层做多渠道兜底与流式回传;存储层把会话、消息、音频、报告分别落库(热数据在 Redis/Mongo,冷数据归档);最后是回放与统计。每个环节配一个你亲手解决的问题(超时、重复、断线恢复),比罗列组件有用得多。

MongoDB 的过期机制是 TTL 索引,而且它不保证准时。 在日期字段上建 expireAfterSeconds 索引,后台的 TTL 监控线程每 60 秒扫一次,把过期的文档删掉——所以删除有分钟级延迟,且只对「字段是 Date 类型或含 Date 的数组」生效。两个常见坑:一是 TTL 索引是单字段的,不能做复合条件过期(要按租户不同时长过期,只能在字段值上做文章或用定时任务);二是删除是通过后台线程做的,量大会有删除压力,不适合当作「精确到秒的过期」。如果要「不删但逻辑上失效」,更稳的做法是查询时带 expire_at > now,TTL 只作为清理手段。