面灵AI→

虾皮后端一面:从头线程/进程通信问到 Kafka 分区,再到 4TB 文件查 int32

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

《面试题目》

  1. 先做两分钟自我介绍,重点展示核心经历。
  2. 实习项目:你负责了什么、最难的点在哪里?
  3. Java 线程池里,多线程之间如何共享数据、完成数据通信?
  4. 线程之间通信有哪些方式(Linux 系统)?
  5. 追问:用共享空间做多线程通信(比如一个全局 Map),会有冲突、指针越界这类问题吗?
  6. 追问:线程安全 Map 与非线程安全 Map 的核心差别是什么?
  7. 追问:ConcurrentHashMap 的底层原理?
  8. 追问:修改副本的过程中,其他线程读取会不会读到过期的旧数据?
  9. 追问:除了共享空间,还有哪些线程间通信方案?
  10. 进程间通信有哪些实现方式?
  11. 管道、Socket 套接字是否属于进程间通信方式?分别是什么?
  12. 进程和线程的相同点与不同点?
  13. 进程、线程、协程的区别是什么?
  14. 进程之间通信的共享内存和线程之间通信的共享内存有什么区别?
  15. CPU 调度的基本单元是进程还是线程?理由是什么?真正执行的时候,到底是进程还是线程?
  16. 用一两句话概括进程与线程的关系。
  17. 什么是僵尸进程?
  18. 什么是孤儿进程?
  19. ISO 七层网络模型从上到下分别是哪七层?TCP/IP 四层模型是哪四层?
  20. 以太网对应网络哪一层?
  21. TCP、IP 分别属于哪一层?
  22. 简述 TCP 三次握手流程。
  23. TCP 拥塞控制机制了解吗,简单说明?
  24. Kafka 集群由哪些核心组件构成?
  25. Broker 集群和 Topic 分区是什么关系?单个 Partition 由单个节点还是多个节点构成?
  26. 一条消息发送到 Topic,是广播到所有分区还是仅存入单一分区?
  27. 发消息时按什么机制决定一条消息落到哪个分区?
  28. Topic 有 20 个 Partition 时,最多可以有多少个 Consumer 同时消费?
  29. 有 20 个 Partition、只有 10 个 Consumer 时怎么消费?要扩容最多能扩到多少?一个消费者怎么拉两个 Partition?
  30. 每个 Partition 对应 Broker 上的一个节点,这个节点是单副本还是多副本?和 replica 是什么关系?多个节点之间怎么并行工作,客户端到底连谁?
  31. 了解分布式锁吗?常见实现方式有哪些?
  32. 追问:MySQL 能否实现分布式锁?
  33. 给你一个 4TB 的大文件,每行一个 int32 数字,但只有 2GB 内存,怎么判断任意一个 int32 是否在这个文件里?
  34. Unix 网络的 IO 模型有哪几种?
  35. 手撕:在排序链表中删除重复的结点,重复的结点一个都不保留。例如 1->2->3->3->4->4->5 处理后为 1->2->5。
  36. 追问:能不用 Set 吗?只用双指针可以吗?一定要双指针吗,单指针行不行?
  37. 算法题二:业务计费公式的代码,如果后续计费区间、价格配置频繁变更,代码该如何抽象设计?

《参考解析》

线程间通信(Java + Linux)。 Java 层有四类:共享内存(堆上的对象,配合 synchronized/ReentrantLock/volatile 保证可见性与互斥)、wait/notify 与 Condition 的条件等待、BlockingQueue 这类并发容器、以及 CountDownLatch/CyclicBarrier/Semaphore/CompletableFuture 这类同步器与异步编排。Linux 层则看 pthread 提供的原语:互斥量、条件变量、读写锁、自旋锁、信号量、屏障,以及无锁的原子操作(__atomic / std::atomic)与 futex。回答时要强调「共享内存 + 同步原语」是同一件事的两半:共享内存只解决「能看见」,可见性与互斥要靠锁或原子。

共享全局 Map 会不会冲突、指针越界。 会。Java 里普通 HashMap 并发写会导致结构损坏(JDK 8 之前会成环,之后也可能丢更新、size 不准),但不会有「指针越界」——Java 没有裸指针,越界只可能发生在数组越界或调用 native 时。C/C++ 里则是另一回事:无锁并发改同一个容器会出现数据竞争,指针指向的节点被另一个线程释放后再访问就是 use-after-free,表现成随机崩溃或读到脏数据。是否要加锁的判据是「有没有并发写」——只读的共享不可变对象不需要锁。

线程安全 Map 与非线程安全 Map 的核心差别。 差别不在「加没加锁」这个表象,而在于「并发下能否保证不变式」。HashMap 不保证任何并发语义:多线程同时 put 可能丢数据、resize 时读到中间状态、size 与迭代结果不可信。ConcurrentHashMap 保证单次操作原子、内存可见,读操作基本无锁(volatile 读),写操作只锁住对应的桶(JDK 8 起是 CAS + synchronized 锁首节点),并发度高、不会整个表阻塞。但它只保证「单次操作」原子,get 再 put 这种复合操作依然不原子,要用 computeIfAbsent/merge 这类原子方法。

ConcurrentHashMap 的底层原理。 JDK 8 的结构是「数组 + 链表 + 红黑树」:Node[] table,key 的哈希高位扰动后定位桶;桶为空时用 CAS 放入首节点,桶非空时 synchronized 锁住首节点再沿链表插入或更新;链表长度达到 8 且容量不小于 64 时转红黑树,退化到 6 又转回链表。扩容支持多线程协同迁移(ForwardingNode 占位 + 分段领取迁移任务),size 用 baseCount + CounterCell[] 分散计数减少竞争。读路径不加锁,靠 volatile 保证节点值与 next 指针的可见性。

「修改副本时别的线程会不会读到旧数据」 这题要分层答:ConcurrentHashMap 的单次 get 一定读到某个已发布的值(可见性由 volatile 保证),但不保证是最新值——并发期间读到的可能是迁移前或刚被覆盖前的值,这是正常的弱一致读。如果需要「读到的一定是某个完整版本」,就要换方案:加锁做读写互斥、用 CopyOnWriteArrayList(写时复制整表,读无锁但写昂贵)、用不可变对象整体替换引用、或者用版本号做乐观校验。回答里点明「并发容器给的是可见性和原子性,不是快照隔离」是加分项。

共享内存的两种语境。 线程共享的是同一进程地址空间里的堆与全局区,天然可访问,成本只是同步;进程共享内存要显式建立(mmap 映射同一文件或匿名共享区、System V shmget/shmat),是内核管理的、跨地址空间的物理页映射,双方各自有不同的虚拟地址,所以不能传指针、只能传偏移。同步上线程用 pthread_mutex,进程间要用带 PTHREAD_PROCESS_SHARED 属性的互斥量或信号量。另外进程共享内存的生命周期独立于创建它的进程,需要显式释放,否则会泄漏。

进程与线程的关系(一句话版)。 进程是资源分配与隔离的单位(独立地址空间、文件描述符表),线程是 CPU 调度的单位,一个进程里的多个线程共享地址空间与资源、各自持有独立的栈与寄存器上下文。CPU 调度的基本单位是线程(Linux 里内核调度的实体叫 task,clone 出来的线程就是一个可调度的 task);但调度器看到的「谁在跑」始终是某个进程里的某个执行流,所以工程上说「以线程为调度单位、以进程为隔离单位」。

僵尸进程与孤儿进程。 子进程退出后内核保留它的退出状态等待父进程 wait/waitpid 回收,这段窗口里它叫僵尸进程(Z 状态),只占一个进程表项不占内存;父进程一直不回收就会堆积,占满 PID 表。孤儿进程是父进程先退出、子进程还活着,它会被 init(或 systemd、或最近的 subreaper)收养,退出时由收养者回收,本身没有危害。这两个概念常被拿来问「怎么排查僵尸进程」——ps -ef | grep defunct 找出来,再看它的父进程为什么不回收(通常是父进程没写 wait 逻辑或阻塞住了)。

网络分层。 ISO 七层从上到下是应用层、表示层、会话层、传输层、网络层、数据链路层、物理层;TCP/IP 四层是应用层、传输层、网络层(网际层)、网络接口层(链路层)。以太网工作在数据链路层(第二层),负责同一广播域内的帧传输与 MAC 寻址;IP 在网络层,负责跨网段寻址与路由;TCP 在传输层,提供面向连接的可靠字节流。三次握手:客户端发 SYN(带初始序列号)→ 服务端回 SYN+ACK(自己的序列号 + 确认号)→ 客户端回 ACK,此后双方进入 ESTABLISHED。要能顺带说清为什么是三次而不是两次:两次无法让服务端确认「客户端收到了我的 SYN」,也无法防止历史重复连接请求造成的资源浪费。

TCP 拥塞控制。 四个阶段:慢启动(拥塞窗口 cwnd 从 1 个 MSS 开始指数增长到慢启动阈值 ssthresh)、拥塞避免(超过阈值后改为每 RTT 加一个 MSS 的线性增长)、快速重传(收到三个重复 ACK 立即重传丢失段,不等待超时)、快速恢复(把 ssthresh 减半、cwnd 设为 ssthresh 后进入拥塞避免)。超时重传时 cwnd 直接回到 1 重新慢启动。现代内核默认是 CUBIC,还有 BBR 这类基于带宽与时延建模的算法。要能说清「流量控制」是接收方窗口 rwnd 限制发送速率,「拥塞控制」是发送方根据网络反馈自我限制,两者共同决定实际发送窗口。

Kafka 的组件与分区。 集群由 Broker(服务节点)、Topic(逻辑消息类别)、Partition(分区的物理单位,一个 Topic 拆成多个分区以实现并行与水平扩展)、Replica(分区的副本,分 Leader 与 Follower)、Controller(负责分区 Leader 选举与集群元数据)、以及 ZooKeeper 或 KRaft(元数据与选举协调)组成;客户端侧还有 Producer、Consumer、Consumer Group 与 Coordinator(负责组内分配与位移管理)。一个 Partition 在逻辑上是一个有序的追加日志,物理上它的每个副本完整地落在一个 Broker 上——所以「单个 Partition 由一个 Broker 承载(多副本时是多个 Broker 各存一份)」,不是把一个分区拆到多个节点。

消息落到哪个分区与消费者的数量关系。 一条消息只会进入一个分区,不会广播到所有分区——「广播」是多个 Consumer Group 各自独立消费同一 Topic 才有的效果,单个组内每条消息只被一个消费者处理。分区选择顺序:消息带 key 时用 hash(key) % partitionCount(同 key 保证同分区、从而保证局部有序);不带 key 时按粘性分区或轮询。消费侧:一个 Partition 在同一时刻只能被同一个 Consumer Group 内的一个 Consumer 消费,所以「20 个 Partition 最多有 20 个 Consumer 真正并行工作」,多出来的会空闲;只有 10 个 Consumer 时每个分到 2 个 Partition,靠 Consumer 的 poll 循环依次拉取;想扩到 20 个就是上限,超过的部分闲置(这也是「分区数决定消费并行度上限」的由来)。一个 Consumer 拉多个 Partition 时,每个分区维护独立的拉取位置(offset),在同一个 poll 里批量返回、按分区分别提交位移。

副本与客户端连谁。 每个 Partition 有 1 个 Leader 和 N 个 Follower(replication.factor 决定总数)。生产与消费都只跟 Leader 交互(Kafka 2.4 起消费者可以就近读 Follower 副本以省跨机房流量,但默认仍是 Leader);Follower 主动向 Leader 发 fetch 拉数据做同步,同步进度落在 ISR(in-sync replicas)列表里。写入时 Leader 按 acks 决定何时应答(0 不等、1 等 Leader 落盘、all 等 ISR 全部确认),min.insync.replicas 与 unclean.leader.election 共同决定「宁可不可用也不丢数据」还是反过来。Leader 挂掉时由 Controller 从 ISR 里选新 Leader。多个节点之间的「并行」体现在不同 Partition 的 Leader 分散在不同 Broker 上,客户端按分区连到各自的 Leader。

分布式锁的三种实现。 ① 基于 Redis:SET key value NX PX ttl 抢锁,value 存唯一标识(便于安全释放),释放用 Lua 脚本比对标识后删除;续期用看门狗;高可用场景用 Redlock(有争议,多数场景更推荐单实例 + 主从 + 业务兜底)。② 基于 ZooKeeper/etcd:创建临时有序节点,序号最小的持有锁,其余监听前一个节点(避免惊群);会话断开自动释放,天然解决「持锁进程挂了锁不释放」。③ 基于数据库:唯一索引插入或 SELECT ... FOR UPDATE,简单但性能差、有连接占用问题。要补通用要点:锁要带超时与自动续期、释放要校验持有者、业务要幂等(锁失效时仍不能重复执行)、以及「锁的粒度」比「锁的实现」更影响正确性。

MySQL 能不能做分布式锁。 能,两种做法:① 建一张锁表,lock_name 上建唯一索引,抢锁就是 INSERT,成功即持锁,失败即被占;释放就是 DELETE;为了防止持锁方崩溃导致死锁,要加过期时间字段并由定时任务清理(或用 ON DUPLICATE KEY UPDATE 配合时间戳做「过期可抢占」)。② 用 SELECT ... FOR UPDATE 在事务里锁住某一行,事务提交自动释放,天然带超时与阻塞语义。缺点是依赖数据库连接(长事务会占用连接与 undo 空间)、性能与并发度远低于 Redis、跨库跨实例不好用。所以答案通常是「能,但只在并发不高、已经有数据库依赖的场景用」。

4TB 文件、2GB 内存查 int32。 int32 的取值空间只有 2³² ≈ 43 亿个,用一个比特位表示「是否存在」正好需要 2³² 位 = 512MB,完全放得进 2GB——这是最优解:扫一遍文件,把读到的数当作下标去置位(位图 / bitset),之后任意查询 O(1)。要注意 int32 有负数,映射到无符号下标即可(加偏移 2³¹)。

如果面试官把条件改成「内存更小」或「不是恰好 int32 值域」,备选方案是:① 分桶外排——按哈希把数分到 K 个文件,每个文件单独载入内存用哈希集合判定,多次扫描换空间;② 布隆过滤器——内存占用极小,但只能给「一定不在」和「可能在」,有假阳性,需要回查文件确认;③ 外部排序后二分——把文件排序落盘,查询时二分查找,代价是预处理时间长。回答时先说位图这个最优解,再讲退化方案,并点明各自的时间/空间/准确率取舍。

Unix 的五种 IO 模型。 阻塞 IO、非阻塞 IO(轮询 EAGAIN)、IO 多路复用(select/poll/epoll,一个线程盯多个 fd)、信号驱动 IO(SIGIO 通知)、异步 IO(io_uring/POSIX AIO,内核完成整个读写后再通知)。前四种在「数据从内核拷贝到用户空间」这一步都是同步的(会阻塞),只有异步 IO 是真正全异步。要能对比 select(fd 上限 1024、每次要整体拷贝与线性扫描)与 epoll(红黑树管理 fd、就绪链表返回、无上限)的差异,以及 LT 与 ET 的用法区别。

手撕:删除排序链表中所有重复结点。 关键是「重复的一个都不留」,所以需要一个哑节点(dummy)指向头,用 prev 指向「最后一个确定保留的节点」。遍历时若 cur->val == cur->next->val,就把这一段值相同的节点全部跳过(内层 while),然后 prev->next 直接指向跳过后的第一个不同节点;否则 prev = cur、cur = cur->next。时间 O(n)、空间 O(1)。边界:头节点就是重复段(dummy 的作用)、整条链全相同(返回空)、只有一个节点、空链表。

追问「不用 Set、只用双指针、甚至单指针」怎么答。 用 Set 的做法是两遍:第一遍记录出现次数大于 1 的值,第二遍删掉这些值的节点,空间 O(n)。双指针(prev + cur)就是上面的写法,空间 O(1)。单指针也能做:让 cur 自己往前走,遇到 cur->val == cur->next->val 时把这一段整体跳过——但跳过时需要有东西「接住」剩下的链表,通常还是得用一个 prev 或哑节点,所以严格说「单指针」是「哑节点 + 一个游标」的写法:dummy->next = head,cur = dummy,判断 cur->next 与 cur->next->next 是否相等。面试官这么追问,本质是在看你能不能把「谁指向谁」讲清楚、而不是模板背下来的。

计费公式的可扩展设计。 核心是把「规则」从「代码」里搬出来,做成数据。推荐结构:一张计费规则表(tier 档位:起止区间、单价、计价方式,如阶梯累进或全额适用),规则带生效时间与版本号,支持热更新;代码里只保留一个纯函数 calc(usage, rules) -> amount,按区间排序后逐档累加,档位开闭区间要统一(如左闭右开)。抽象上可以做三件事:① 用策略模式把「阶梯累进」「分段全额」「保底 + 封顶」等计价方式各写成一个策略,规则里指定用哪个;② 用责任链或规则引擎处理优惠、折扣、免计费额度,让它们与基础计费解耦;③ 金额一律用最小货币单位(分)的整数计算,最后再做显示格式化,避免浮点误差。可测试性上,把「一组输入 + 一份规则版本 → 期望金额」做成表驱动用例,规则变更时跑回归;再加一个「计费明细」的输出(每一档用了多少量、按什么单价、小计多少),线上对账与客服解释都靠它。