美团

一面

题目1

请说明进程和线程的区别与联系。操作系统中的虚拟内存是如何实现的？谈谈乐观锁和悲观锁，以及它们在Java中的具体实现（如CAS、Synchronized）。AQS（AbstractQueuedSynchronizer）的原理是什么？请举例说明（如ReentrantLock）。当向一个线程池提交任务时，它的执行流程是怎样的？（考虑核心线程、队列、最大线程、拒绝策略）

介绍一下Redis的持久化机制有哪几种，它们各自有什么优缺点？如何保证缓存与数据库双写一致性？谈谈MySQL的事务隔离级别，以及MVCC是如何在可重复读（RR）级别下工作的。什么是覆盖索引和回表？在使用联合索引时，需要注意哪些最左前缀匹配原则？

请描述一下JVM的类加载过程，以及双亲委派模型。G1垃圾收集器相比于CMS有哪些优势？什么情况下会发生OOM（堆内存溢出），请举例说明几种场景。Java中的强引用、软引用、弱引用、虚引用之间有什么区别？

题目2

1：自我介绍

2：HashMap1.8底层数据结构和put流程

3：jvm底层和OOM发生区域

4：roc调用流程

5：慢SQL调查流程

6：mysql隔离级别和如何实现的，以及MVCC

7：唯一ID，一致性哈希

题目3

Bean的生命周期

Spring怎么解决循环依赖问题

Spring的IOC、AOP

Spring的事务传播机制

事务传播机制的底层实现

TheadLocal的key为什么要设置成弱引用

TheadLocal的value为什么要设置成强引用

TheadLocal怎么防止内存泄漏

TCP的三次握手和四次挥手

TIME_WAIT发生在哪里，以及为什么需要TIME_WAIT

UDP怎么设置成可靠的

votaile 关键字的作用，以及votaile 禁止指令重排的底层实现

解释一下SYN的泛洪攻击

怎么防御泛洪攻击

题目4

1. ThreadLocal在什么情况下会导致out of memory？

2. 阿里规范中为什么要求用static来修饰ThreadLocal变量？

3. 存储100万数据时，选HashMap还是ConcurrentHashMap？

4. 多线程情况下使用HashMap会导致什么问题？

5. HashMap扩容时需要注意什么？

6. 仿大众点评项目中缓存空值具体是怎么实现的？

7. 布隆过滤器的误判率大概是多少？

8. 仿大众点评项目中，类似微博大V发博客的场景，使用推模式还是拉模式？大粉丝量时推模式会有什么问题？

9. Redis分布式锁为什么要使用Lua脚本？纯Java代码为什么不可以？

10. 为什么选用Websocket？除了Websocket，是否考虑过其他协议（如谷歌的相关协议）？

11. 分布式环境下用schedule的关单会有什么问题？

12. 若系统扩大为分布式且单量增大，解决定时任务问题的思路有哪些？

13. 日志框架用的是log4j还是log4j2？日志应在哪些地方重点打印？

14. 碰到老应用、老系统日志不全时，如何最快地加上基础日志打点？

15. 为什么选用Mybatis plus而不选用JPA？

16. 线程池在系统里用在哪些位置？

17. 线程池的核心参数有哪些？从核心线程数达到最大线程数需要什么条件？

18. 在优惠券秒杀场景下，阻塞队列应设置多大？

19. RabbitMQ与Redis stream的推流最大区别是什么？

20. 仿大众点评项目中，最重要的几张表是哪几张？订单表应加什么索引？

21. MySQL的日志指的是哪些？集群模式最主要依赖的日志是什么？

22. 生产环境中如何避免主从同步延迟带来的故障？

23. JDK 11、17有哪些新特性？

题目5

说一下 JVM 的内存结构（运行时数据区）有哪些？每一块的作用是什么？

Java 中对象的内存分配过程是怎样的？对象分配在堆还是栈？

什么是栈上分配、逃逸分析？是否可以让对象不分配在堆上？

什么情况下对象会进入老年代？如何判断对象“是否存活”？

直接内存（Direct Memory）是什么？你在什么场景下用过它？

JVM 中常见的垃圾回收器有哪些？它们的适用场景？

Serial、ParNew、CMS、G1、ZGC 有什么区别？你项目中用的哪一个？为什么？

Minor GC 和 Full GC 有什么区别？分别在什么情况下发生？

如何避免或减少 Full GC？有哪些排查方法？

GC Roots 有哪些？JVM 是怎么判断一个对象是否需要回收的？

题目6

ArrayList和hashmap扩容机制

Java并发容器和锁

jvm参数设置 —- 堆内存和垃圾回收器

如果新生代的垃圾回收一直清不到0，怎么解决？

full GC

垃圾回收机制

类加载机制和双亲委派机制

IOC —- 还有IOC相关的，忘记是什么了

Bean生命周期

MySQL索引的注意事项、事务

MVCC

当前读和快照读

Redis数据结构

RocketMQ与kafka

rocketmq有哪些主要部分

消息重试

消费者的消费模式

消费者如何保证幂等

RocketMQ消息有序吗？

http状态码，对应着是哪个环节出现问题

TCP三次握手和四次挥手 为什么挥手是四次？

lInux查最近的日志 —- tail -f | grep XXX

linux其他命令 查看进程 ps

题目7

1.自我介绍

2.实习拷打

3.讲讲javac过程，结合编译原理的东西详细分析

4.讲讲你写的一个java代码跑起来的过程，例如编译运行和解释运行

5.面向对象的几个特性和举例子说明

6.springboot容器启动过程

7.讲讲list，map，set几种基本数据结构和使用场景

8.假如你用一个arraylist，你已经知道里面会存1w条数据了，那该怎么办

9.collections下的加锁和数据结构本身例如chw的加锁操作有什么区别

10.手撕SQL:

员工编号-id，部门-dep，薪酬-salary

求找到所有薪酬大于部门平均工资的员工

要求多种解法

不知道想要哪种，除了常规的，还写了一种 avg（salary）over（partation by dep）as avgSalary这种

11.手撕链表中删除重复元素

12.讲讲大模型中的知识蒸馏是怎么做的

13.整体介绍介绍你对于agent，work flow，rag，mcp，a2a的理解

题目8

1. 看你简历上写了几个项目，可以挑一个你觉得最有代表性的介绍一下吗？

2. 我看你提到了mcp，能解释下它是什么吗？主要起什么作用，在什么地方起作用？

3. 我们来聊聊基础吧，HashMap是线程安全的吗？为什么？

4. StringBuffer和StringBuilder，它俩有什么区别？

5. TCP和UDP，能分别说说它们的特点和常见的应用场景吗？

6. 来一道概率题吧：现在你只有一个能生成1到5随机数的rand5()函数，怎么用它来实现一个能生成1到7随机数的rand7()函数？（讲了大体思路没讲具体思路 估计死了)

7. 你之前有做过全栈开发吗？

8. 我们来深入聊聊MySQL索引。能介绍一下吗？为什么它通常用B+树来实现？B+树的每个节点里都存了些什么？另外，一张表里可以有几个聚簇索引？（把我问死了）

9. 来个系统设计题。假设我们要搞一个秒杀活动：晚上八点开抢1000台手机。你会怎么设计这个秒杀系统？

10. 你觉得，一个好的Prompt通常需要包含哪些要素？

11. 在我们平台里，Agent模式和Ask模式，它俩有什么区别？

题目9

hashcode equal什么时候需要重写

hashmap原理

hashmap是线程安全的吗

不安全的话用什么？他的原理是什么样的

线程池使用过吗？怎么用的？什么场景？

spring事务怎么做到的

spring事务传播机制

mysql使用

mysql怎么建索引？怎么判断是否要建索引

mysql索引失效？

mysql慢查询排查

题目10

1.自我介绍

2.项目难点有什么

3.Redis常用数据结构有哪些

4.Redis缓存击穿、缓存雪崩是什么，解决方案

5.equals和hashcode

6.TCP三次握手

7.MySQL索引类型有什么，索引失效场景

8.一个主线程正在进行，现在有个子线程，怎样才能让主线程停止，等到子线程执行结束之后再恢复运行

9.创建线程的方式有哪些

10.平时怎么用AI学习的

题目10

1.hashmap如何解决哈希冲突，红黑树化为何阈值为8

2.cglib和jdk代理区别，哪个性能好

3.联合索引失效 如何改进

4.synchonized reentrantlock区别

5.mq如何保证可靠性，顺序性

6.ArrayList LinkedList区别

7.OOM怎么排查

8.线程池核心参数 原理 四种拒绝策略 举个例子

9.缓存穿透 雪崩

10.分库分表 附属表 基因法 优缺点

11.mysql隔离级别 可重复读怎么避免幻读

12.G1怎么避免内存碎片

13.Mysql oracle区别

13.用过哪些AI，用途，工作中遇到别人代码bug怎么办

14.手撕 二叉树层序 最长重复子数组

题目11

1、项目、实习拷打
2、violate关键字作用
3、如何保证线程安全
4、支持原子性操作的方法
5、简述Spring的ioc和aop的核心思想
6、mysql的acid特性
7、慢sql如何优化
8、explain关键字解释
9、Redis常用数据结构以及应用场景
10、WebSocket的工作原理
11、如何优化你项目中使用的WebSocket的业务
12、FTP中的keep-alive
13、TCP特性
14、UDP和TCP应用场景，如何使得UDP可靠
15、对前端的了解，对vue的认识
16、java中Sort的原理

题目12

1.问实习内容
2.并发工具类
3.介绍项目背景
4.项目框架设计
5.项目如何面对高并发场景
6.线程池八股
7.项目接口和高并发
8.手撕：合并两个有序数组
9.Mysql日志
10.MVCC

题目13

1. 自我介绍，过往项目经历、实习经历
2. 日常怎么运用 ai 大模型
3. 讲一下 java 8 lambda 表达式
4. osi 7 层结构模型，每层的作用是什么
5. tcp 和 udp 的区别，tcp 超时重传、流量控制机制
6. 怎么运用大模型，为探店博主或者商家提供服务，包括根据用户上传的图片或关键字，生成一个基础的探店笔记（追问 prompt 工程、怎么解决幻觉）
7. 讲实习遇到的困难

题目14

1. 自我介绍，特别问了AI大模型在你学习过程中给你的帮助
2. 栈和队列的区别；生活中站和队列分别有什么应用场景？
3. Lambda表达式的作用和使用场景？Lambda表达式和匿名内部类相比有什么优势？
4. 解释消息队列的消息投递机制，比如“至少一次”、“至多一次”、“恰好一次”？“至少一次”投递机制会出现什么问题，怎么解决？
5. 设计一个考勤管理系统，如何保证考勤记录的真实性？如何防止考勤过程中用户信息被人篡改？
6. 利用AI大模型，为新入驻的商家提供一个“7×24小时的AI导师”，可以回答商家提供的各类问题？
   追问：如果线上发现模型返回的JSON经常缺字段或格式错乱，导致下游服务解析失败，如何从Prompt设计、模型参数或后处理等方面系统性解决这个问题？
   追问：后处理阶段发现模型生成的内容与预期字段不匹配，你会如何设计检测机制来发现和解决这些问题？
7. 描述一次你成功识别并解决了一次潜在的、尚未显形的问题，你是如何预见并采取行动的？

题目15

1、自我介绍+项目拷打
2、对于分库分表，是按照什么分的
3、为什么要把数据分开存储，不能都存到分布式数据库里吗？分布式数据库和普通数据库区别是什么
4、当数据库表超过2千万之后，处理方案是什么？
5、有学过计算机相关的课程吗，对哪一门比较熟悉（这里我说网络）
6、说一下滑动窗口的原理
7、讲一下三次握手和四次挥手
8、提到close_wait 和 time_wait，说一下这两个状态过多的影响，以及哪个危害更大。
9、阐述一下类加载的过程，包括具体加载到什么地方
10、元空间和方法区会存放哪些信息
11、有使用过AI吗？现在大模型的幻觉问题比较大，平时处理方法是什么？
12、知道RAG吗？阐述一下Rag原理，以及它是如何处理大模型幻觉问题的
13、说一下未来的职业规划？如果工作内容不符合你的规划呢？
14、知道大模型的生成数据流推送的方案吗？就是如何逐字输出的？
15、WebSocket 和 SSE 的区别是什么？
16、单工一定比全双工性能要好吗？
17、对于分表后的主键ID是怎么处理的

题目16

15min
实习业务介绍及问答
聊聊 RAG 和 Embedding？它们是啥，有啥用？
你是怎么学大模型的？
你觉得大模型能在哪些地方实际用起来？

10min
讲讲悲观锁和乐观锁？
消息队列有啥用？
RocketMQ 和 Kafka 有啥区别？底层实现上有什么不一样？
Kafka 消费消息比 RocketMQ 快吗？为啥？
顺序消费有啥要注意的？

15min
布隆过滤器一般用在哪？原理是啥？
MySQL 的索引是啥原理？有啥用？
B+ 树和 B 树有啥区别？
MySQL 的隔离级别有哪几种？分别怎么实现的？
设计一个外卖流程：用户下单、商家接单、骑手派单，大概是个啥过程？会用到哪些数据结构和算法？

题目17

1. redis为什么快，性能为什么高？
2. redis里面基本的数据类型有哪些？
3. 一些数据类型也是redis优化之后导致redis快的原因，能够就其中一个redis数据结构的优化来举出一个实际的例子吗？
4. 你能先描述一下跳表的数据结构长什么样子？
5. 跳表空间复杂度是多少？
6. 说说对redis事务的理解？
7. 说说对mysql事务的理解？
8. 说一下redis的持久化方案把？
9. redis主从同步主要采取哪种形式？
10. redis有几种部署模式？
11. 你觉得集群模式和哨兵模式的主要区别是？
12. 集群模式中如何出现一个redis热点key的情况，怎么做防止节点单点压力过大？（我回答是业务层面解决，每个节点都缓存热点key，用一个哈希集合存储热点key，直接快速判断是否走本地查询，而不是哈希索引节点）
13. 说一下mysql的隔离级别以及每种隔离级别下可能出现的问题？
14. 说一下可重复读是怎么解决不可重复读的问题？
15. 说一下什么是聚簇索引？
16. 聚簇索引和聚簇索引有什么区别？
17. 数据结构的区别在哪里？都用的是B+数吗？
18. B+数的结构原理是什么？
19. 什么是覆盖索引？
20. 覆盖索引有什么好处？
21. 最近的话，AI大模型比较火，你有没有学习AI大模型相关的原理，大模型微调了解过吗？

题目18

1.介绍多态，重载、重写底层如何实现
2.野指针和悬挂指针出现场景，产生什么后果，如何解决
3.介绍智能指针，什么操作会导致共享指针引用计数加1、减1
4.如果想把一个智能指针的释放控制在某一个线程内应该怎么做？这个我不会，面试官说要让指定线程一直持有着它，然后再释放，我还是没太懂
5.对堆和栈的理解
6.申请堆空间的方式，两种方式的区别
7.STL库有了解吗？vector有了解吗？
8.除了添加元素时容量不够会扩容，还有什么时候会扩容？这个我不知道，面试官说还有一个用来动态扩容的容器阈值，当前申请的内存超过阈值时会提前申请。
9.vector底层数组在内存分配上是什么特性
10.还有其他内存分配方式吗
11.为什么有epoll，epoll的水平触发和边缘触发
12.tcp三次握手
13.对于客户端和服务器而言，是怎么认出这个tcp连接的？我当时一直没get到面试官的意思，现在想想应该是想让我回答四元组标识一条连接吧？
14.客户端和服务器的fd都是什么时候生成的
15.连接队列满了会给客户端返回什么？不清楚，面试官说reset
16.进程和线程。我当时有点昏头了，说进程不能很好的利用多核cpu，面试官说多进程也可以用多核
17.进程间通信
18.linux排查问题的相关命令：查网络连接、查网络连接个数、grep反向查找

题目19

说一下java并发编程
多个线程访问同一个资源 怎么设计
多个线程访问同一个资源 用sycoenized锁性能如何 如果优化的话怎么优化
分布式事务
缓存击穿
缓存击穿和缓存穿透的区别
设计一个新闻推送
如果用ai进行新闻推送分类的话 提示词怎么写
如果让你用ai生成营销策略的话怎么设计提示词
如果大模型出现产地硬信息描述不符怎么办
如果大模型回答缺一个点 怎么办
你项目中最有难度的一个问题 如何排查的

题目20

2min

自我介绍

15min

实习业务介绍及问答

Q: RAG和embedding了解吗，是什么有什么作用

RAG检索增强生成，可以拓展模型上下文，缓解模型幻觉和时效问题。

embedding可以将非结构化数据（文本图片视频）转化为结构化数值向量，向量每个数值代表某个维度上的特征，以此让机器也能理解分类和检索数据。

Q: 你是怎么学习大模型的

论文、博客

Q: 大模型你觉得有哪些可以落地应用的地方

AI coding、豆包形式AI应用、行业定制agent和传统互联网业务赋能。

​

10min

Q: 悲观锁和乐观锁概念

是否强制加锁，区别于在进入共享资源区之前是否允许其他请求修改共享资源。

Q: 消息队列的作用

削峰填谷、异步化、服务解耦。

Q: RocketMq跟Kafka区别，底层实现有什么不同

架构相似，功能RocketMq更丰富，吞吐量KafKa更大，底层零拷贝策略不同。

Q: kafka消息消费比RocketMq快吗，为什么

Kafka sendfile零拷贝(没有用户态和内核态之间的拷贝)，RocketMq mmap零拷贝(比sendfile多一次拷贝)。

Kafka 分区消息顺序写磁盘且可以通过分区偏移量直接从日志文件中读到数据，RocketMq队列消息都存在全局CommitLog中，只是同一队列消息有序，但在磁盘上位置可能分散，且定位消息位置需要两次寻址。

Q: 顺序消费要注意什么

生产者生产的消息要发送到同一个队列，指定单个消费者单线程或多线程加锁消费该队列。

​

15min

Q: 布隆过滤器使用场景及原理

缓存穿透+ 哈希函数 + bitMap。

Q: mysql的索引原理，作用

多叉自平衡树B+树，将数据按索引字段顺序编排，查询效率更高。

Q: B+树跟B树的区别

B+树仅叶子节点存储数据，树高度更低减少磁盘IO且查询效率稳定，叶子节点双向连接方便范围查询。

Q: mysql的隔离性有哪些，怎么实现的

读未提交、读已提交、可重复读和串行化，其中读已提交和可重复读通过MVCC和undo log配合实现。

Q: 用户下单，商家接单，骑手派单中间大致是个什么样的过程，涉及什么数据结构和算法上的考量

​

7min

括号匹配

​

8min

反问

消息队列没回答好，因为我不了解kafka，但最近被问到好几次，最后一道场景题更是懵逼。

题目21

1.redis的事务和mysql的事务区别

2.redis事务在命令入队期间出错了会不会回滚

3.redis事务底层是如何实现的？（没看过，随便说的应该是放到一个事务队列依次执行的

4.redis线程模型

5.redis持久化方式，只用aof行不行

6.redis哨兵模式，如何判断挂没挂（心跳+Gossip

7.redis集群模式，如何判断节点挂了和后续的选举动作

8.redis缓存淘汰策略

9.mysql的delete、truncate、drop的区别（当时脑子懵了，以为问的都是删除行的操作，后两个删除行没听说过啊。。。）

10.mysql持久化怎么实现的？

11.什么是MVCC以及MVCC怎么实现的？可重复读和读已提交怎么实现的

12.innodb引擎层的查询优化（解释了索引下推和select多的时候不走索引

13.慢sql排查优化

14.项目分库分表，数据多大需要考虑分表

15.手撕：接雨水好久没复习了不会，换了道层序遍历+单例模式（我哭死

16.volatile解释

17.synchronized底层实现原理，具体说Monitor的结构和c++的objectMonitor

18.synchronized和reentrantlock，怎么实现非公平锁。说下juc包下你说过的类有什么

19.线程池参数（7个，一段时间没复习了说了5个），核心线程数怎么设置，队列设多大（给了个响应速度要求高的场景，当时没敢说队列设为0，只说了尽量小，后面看了个美团的博客一模一样的场景。。。）

20.阻塞队列有哪些（原来有这么多BlockingQueue。。。）

题目22

1.一上来自我介绍都没有，自己问

2.java线程池，从参数到流程

3.线程池是怎么把任务给线程执行的？
（我前面已经讲过线程池的流程，阻塞队列啥的，我说不就是还没到核心线程数就新建线程执行吗，面试官说不不不，就是线程池怎么把任务给线程执行的，我又说了线程池提交任务的execute和submit，面试官又重复不不不，到这里我没招了，然后问我没看源码吗）
刚下来查了会ai，源码是有一个worker对象对应线程，然后有run方法和runwork方法。怪我没看源码。

4.看过spring源码吗（看八股的时候或多或少看过，愣了几秒回没看过）

5.jdk和cglib动态代理，为什么jdk要目标类实现接口的（我说jdk是反射，通过代理类实现相同接口，覆盖，起到代理效果。面试官还问为什么要接口，又一次不知道怎么开口。ai说：JDK动态代理依赖于接口的多态性。如果没有接口，代理类无法确定需要生成哪些方法）

6.mysql慢查询，深分页怎么优化

7.mysql索引失效情况

8.mysql优化

9.redis你一般用来干什么，讲讲项目怎么用的

10.redis5种数据结构

11.跳表结构，跳表查询时间复杂度

12.跳表的索引高度是怎么确认的（又一个不知道的，我结结巴巴说他自动生成的。ai说：在跳表中，每个节点的索引高度（即该节点有多少个指针）是通过随机化方法确定的。具体来说，通常使用一个随机数生成器来决定每个节点的索引高度。这种方法的优点是简单且高效，同时能够保证跳表的平均性能。）

题目23

\1. 自我介绍。

\2. 拷打项目。

\3. HashMap 是怎么解决哈希冲突的？

\4. 红黑树和 AVL 树有啥区别？

\5. 排序算法有哪些？哪些是稳定的？

\6. TCP 是怎么保证可靠传输的？

\7. 讲讲拥塞控制？

\8. MySQL 是怎么做到事务隔离的？隔离级别有哪几种？

\9. Spring Boot 里用到了哪些设计模式？

\10. 你还知道哪些设计模式？

\11. 面向对象有哪些特性？

\12. 聊聊设计模式的六大原则，挑两个讲讲？

题目24

你的学习路线是啥？

为啥用 Spring Cloud？

啥是自动装配？

聊聊 AOP 和 IOC？

IOC 有啥用？和单例模式有啥区别？它具体是怎么解耦的？

为啥用 B+ 树？

MySQL 的事务隔离级别有哪几种？

MVCC 为啥解决不了幻读？

讲讲 RabbitMQ？

如果让你来设计 RabbitMQ，你会怎么做？

Redis 有哪些数据类型？

Sorted Set 是怎么实现的？

为啥用跳表？

JMM 模型是啥？

进程和线程有啥区别？

volatile 关键字底层是怎么保证可见性的？

TCP 和 UDP 有啥区别？

题目25

\1. 在日常学习工作中如何使用大模型？举一个具体场景案例

\2. HTTP 和 HTTPS 的区别？HTTPS 对称加密和非对称加密如何应用？

\3. 消息队列消息发送方式？

\4. 缓存穿透成因及解决方案？布隆过滤器局限性？

\5. 帮助商家回复用户评价的大模型方案设计？面对用户评价中恶意评价、prompt 攻击之类的如何解决？

\6. 项目遇到的难题？如何找出难题的具体原因？详细说明白

题目26

HTTP 和 RPC 有啥区别？

数组和链表有啥区别？

哈希表的实现和底层是啥？具体怎么查找？Redis 的哈希底层结构是啥？

VARCHAR 和 CHAR 有啥区别？

事务四大特性是啥？怎么实现的？

从输入网址到页面显示，发生了啥？

Redis 有啥优点？

聚簇索引和非聚簇索引是啥？

联合索引，面试官举了个例子问会不会失效。

啥是回表？啥是覆盖索引？

大 Key 问题怎么解决？

熟悉哪些设计模式？

题目27

1.redis的提前缓存的同步链路怎么实现？

2.rabbitMQ的幂等性怎么实现？

3.你在开发时怎么提高接口性能？

4.java的常用集合介绍一下？

5.哪些集合是线程安全的哪些是线程不安全的？

6.HashMap和concurrentHashMap的对比？

7.ConcurrentHashMap线程安全怎么实现？

8.java的锁机制介绍一下？

9.ReentrantLock的实现原理介绍一下

10.volatile关键字介绍下

11.java创建线程池怎么实现？

12.线程池的工作原理？

13.拒绝策略都有什么？

14.你项目中使用到了两个线程池，他们的拒绝策略不一致是怎么考虑的？

15.jvm调参怎么实现？

16.什么是GC？

17.知道哪些垃圾回收器？

18.jvm怎么分析线上进程线程对象的信息？

19.性能分析工具有了解过吗？

20.你的工具是怎么使用的？

21.springboot的启动流程讲一下？

22.在 Spring 启动过程中，若要在其生命周期的特定阶段执行自定义操作，怎么实现？

23.mysql的底层索引的数据结构是什么？

24.你都知道哪些索引？

25.怎么分析建立的索引有没有生效？

26.什么是索引失效？

27.联合索引建立之后，使用了两个字段做过滤，那么有没有可能不走索引？

28.mysql基于成本的优化考量通过什么算法来实现的？

29.mysql怎么分库分表？什么情况下分库，什么情况下分表？

30.redis的数据结构有什么？

31.解释一下缓存穿透、缓存击穿和缓存雪崩？怎么解决？

32.高并发系统中怎么保证数据一致性？

33.加锁如何保证数据一致性？

34.rabbitmq介绍下底层原理？

35.当一条消息被发送到 RabbitMQ 集群后，这条消息去哪了？

题目28

GC Roots怎么选择？

常见的垃圾回收算法？

CMS用什么算法？垃圾回收过程介绍一下？

CMS怎么解决标记清除的内存碎片问题？

G1垃圾回收过程介绍一下？

G1怎么判断哪个region是最有价值的region？

什么方法可以不遍历老年代，对新生代没被引用的对象进行回收？

Mixed GC听过没有？

InnoDB的ACID怎么实现的？(把三大日志MVCC隔离级别都吟唱了一遍)

没有binlog行不行？(答的主从同步和二阶段提交)

Redis支持事务吗？(忘了)

Redis主从怎么保证高可用的？(吟唱主从同步过程+哨兵集群)

哨兵集群选主怎么选的？(忘了，说了个投票，追问不会)

题目29

为什么技术选型上为什么要选用Redis做token 的缓存？
不用Redis的话，怎么实现过期？
用jwt携带信息，有没有可能客户端把过期时间篡改？
token完整的生命周期以及前后端的整个交互流程？
怎么防止AI识别出验证码导致恶意登陆？
建联合索引的SQL语句？EXPLAIN语句输出的有哪些字段？大概是什么含义？
最左前缀匹配
IOC和DI是什么？之间是什么关系？
Spring、 Spring MVC、 Spring Boot，三个有什么区别与联系？
Java创建线程池的方式？ThreadPoolExecutor有哪些参数？拒绝策略有哪些？
异步创建订单以后，效率、成本以及用户体验，哪一方面有提升，哪一方面有降低？
订单量特别大，怎么提升kafka的整个的吞吐率？
Kafka的订单消息有哪几种丢失的情况，丢了怎么办？

题目30

\2. AI 应用题，用自然语言与AI对话，生成一个美团外卖的通用订单详情页面。
\3. 平时会关注ai相关的知识吗？有哪些渠道去学习ai
\4. HashMap的底层存储结构？
\5. 为什么JDK1.8之后会有一个链表红黑树的转换，为啥不都用红黑树？
\6. ConcurrentHashMap怎么保证的线程安全
\7. equals() 和 == 有啥区别
\8. int a 可以和 Integer B 用 == 进行比较吗
\9. int 和 Integer不给赋值的话初始值是一样的吗
\10. 什么时候要用线程池 线程池的核心参数
\11. 三次握手的过程
\12. 为什么要有三次，两次不行吗
\13. Mysql有哪几种存储引擎
\14. 为什么现在大多数都用InnoDB而不是其他的，好处体现在哪里
\15. 为什么要用事物？
\16. 聚簇索引和非聚簇索引的区别是什么
\17. 给定一个表（a主键, b普通索引, c无索引），查询 SELECT a,b,c WHERE b = ? 会走索引吗？具体流程是怎样的？
\18. 这个例子在什么情况下可能会索引失效？
\19. 你提到优化器，它怎么判断扫全表比走索引更快？
\20. 如果索引变成 a主键 和 (c, b)联合索引，还是查 WHERE b = ?，能走到索引吗？
\21. 是否了解索引下推？

题目31

1.为什么会出现缓存穿透的问题？

2.缓存和数据库的一致性

3.修改数据库后，为什么不直接update缓存，而是删除缓存

4.拷打强一致性和最终一致性

5.缓存击穿

6.你的意思是重建业务不复杂的key是没有缓存击穿的风险是吗？

7.热点key的含义

8.雪花算法

9.雪花算法生成ID的逻辑

10.倒排索引

11.全文索引

12.和聚簇索引有什么区别

13.算法：爬楼梯

14.算法：编辑距离

15.算法：两个有序链表合并

16.简单SQL

17.MVCC

18.JVM内存模型

19.Integer a = new Integer(100); a在哪

20.Integer b = new Integer(100); a==b？

21.integer c = 100; a==c?

22.线程池核心线程数和最大线程数的区别#java

题目32

\1. AI Agent项目的主要目的是什么？

\2. 这个项目最大的挑战是什么？

\3. DDD是什么？

\4. DDD的使用场景和解决的问题是什么？

\5. AI Agent项目中DDD实现的大致步骤？

\6. 领域识别和划分部分的思路是什么？

\7. 外卖项目中支付和营销拼团服务是如何拆分的，和DDD的异同？

\8. 索引优化具体是怎么做的？

\9. 实现商品名称模糊搜索的方案思路有哪些？

\10. MySQL慢查询的优化方法有哪些？

\11. 如何用锁和幂等解决超卖问题？

\12. 外卖项目中责任链、工厂、状态模式的选择思路是什么？

\13. 如何设计一个用户邀请系统（库表和API）？

\14. 对比Redis和Caffeine的优劣势及使用场景？

\15. JVM的内存模型和划分是怎样的？

\16. 对比MyBatis和MyBatis-Plus的优缺点？

题目33

1.base 业务
2.websocet选型 和sse区别 和短轮询区别
3.假如引入新组件出现问题 怎么解决
4.了解哪些限流策略
5.滑动窗口会有什么问题
6.分布式锁的命令 分布式锁过期时间怎么考量的 上线后有没有出现过什么问题
7.假如redis断流了 如何处理
8.多表数据怎么同步到同一张es宽表上
9.es和db的对账策略
10.假如对账没对出问题 兜底策略怎么设计
11.对降级策略以及组件了解多少
12.缓存用的什么组件 有哪些需要配置的信息
13.访问rpc接口 哪些因素影响接口耗时
14.mysql索引 慢查询优化经验
15.mysql事务等级 每个可能出现的问题
16.可重复读怎么实现的
17.mvcc具体讲一下
18.redis的string zset原理

题目34

java的基本类型及其包装类，为什么已经有基本类型，还需要包装类型

包装类的自动装箱和拆箱（Integer两道题目）

java的两种异常类型（Exception和error）

抽象类和接口的区别，使用时期的选择

为什么一般使用线程池，而不是每次都直接使用thread

线程池初始化位置

线程池有那些核心参数

核心5，最大10，等待队列上限50，来了20个任务，此时线程池里面有多少个线程

一个项目有很多个线程池，发现线程特别多，线程又不怎么活跃，此时怎么处理，合并线程池抢占激烈怎么办

java如何保证线程安全的方式

CAS具体的流程，另一个线程怎么感知变量是否修改

concurrentHashMap put的流程

mysql innodb引擎b+树，为什么使用b+树

联合索引，排序的顺序

msyql主从架构

一条sql语句的执行流程

消息队列MQ在系统中起到的作用

kafka有哪些部分组成

MQ消息积压的问题

partition的数量小于消费者的数量

partition扩容可能会出现的情况或者代价

题目35

\1. TCP VS UDP
\2. TCP的流量窗口，慢启动
\3. TCP拥塞算法
\4. TCP的连接
\5. TCP失序到达处理
\6. OSI七层模型，从上到下与从下到上，两种情况的应用场景
\7. 用户态与内核态
\8. 用户态内核态频繁切换具体会损耗什么
\9. 我要进行一个读取excel并发送的操作，期间会涉及到几次内核/用户的切换，以及发送的介质
\10. Redis单线程与多线程
\11. Redis的多路复用与具体实现原理，相比于别的方法有什么优势
\12. Redis数据一致性

题目36

\1. 自我介绍

\2. 拷问实习

\3. 接口耗时有了解过吗，数据库的执行耗时。

\4. 举一个实际做的数据库优化的例子？

\5. 项目中商品名称、品牌、价格范围，商品数量，如果你去搜的话有这么多选项，你是去如何优化一下索引的？

\6. ES查询流程

\7. ES去做分布式查询的流程

\8. ES分片有了解过吗？

\9. 商城里面缓存预热怎么做的？

\10. 缓存之间同步怎么去做的？

\11. 在更新缓存的时候，先更新一级缓存还是二级缓存

\12. 二级缓存什么时候会更新到一级缓存？

\13. 一级缓存和二级缓存的容量是一样大的吗？

\14. redis脚本和lua脚本之间的配合有使用过吗？

\15. 秒杀防超卖

\16. Redis lua脚本中有5条命令，第三条失败会会滚吗，后面两条会执行吗？

\17. 秒杀这里这么保证缓存的数据和数据库的数据是数据一致的？

\18. 如果用MQ保证的，消息发送失败怎么办？

\19. 如果MQserver端挂了，消息发不过去，还能成功吗？如果缓存已经扣减，然后MQ宕机，那么DB和缓存数据不一致，怎么解决？

\20. 用的哪个分布式锁？怎么实现的？

\21. 网关登录验证鉴权怎么做的？

\22. Nginx和网关的功能相同点和区别

\23. 介绍一下网络协议一共几层

\24. TCP和UDP主要的区别和场景

\25. HTTP和HTTPS主要区别

\26. 那HTTP为什么还会存在？

\27. 了解过LinkedHashMap?

\28. 为什么使用红黑树？

\29. 在HashMap里为什么不用其他的树？介绍一下红黑树

\30. 介绍一下平衡二叉树？

\31. ThreadLocal有用过吗？介绍一下。

\32. ThreadLocal的存储结构？源码有了解过吗？

\33. 假设现在有四个核心线程，八个最大核心线程数，任务队列容量为4，先提交四个任务，再去提交新的四个，核心线程处理四个，非核心线程处理4个需要十个小时，核心线程处理的快，在非核心线程处理时，核心线程空闲，这样不会浪费资源吗？

\34. 核心线程和非核心线程有一个标识？

\35. 介绍一下任务队列？各自有什么区别？

\36. 无界队列设置容量和有界区别，了解过底层的源码吗？

\37. 数据库的索引数据类型有了解过吗？B+树的了解。

\38. B树和B+树对于非叶子节点来说，一个存数据，一个不存数据，有什么区别？

\39. Mysql的锁？

\40. Spring的循环依赖的问题？怎么解决？

\41. 垃圾回收器用的什么？配置大概是多少？

\42. G1的回收过程？

\43. Shell命令查看占用80端口的线程ID怎么看？

\44. Shell命令查看某一个进程的进程ID怎么看？

\45. 说一下快排

题目37

你的项目中有哪些亮点或难点？

MySQL中，如果监控发现 CPU 和内存较高、连接较慢，可能是什么原因？排查方向有哪些？

MySQL中哪些查询可能导致慢查询？如何避免？

MySQL中建立了联合索引 (a, b, c)，查询条件是 b > b1 and a = a1 时，索引是否会失效？为什么？

MySQL 为什么使用 B+ 树作为索引，而不是其他数据结构（如 AVL 树、红黑树）？

数据库事务的四种隔离级别是什么？分别解决了哪些问题

Redis 的常见数据结构有哪些？分别适用哪些场景？

为什么 Redis 适合作为缓存？

Redis 集群的分片原理是什么？（key 如何找到对应节点）

Spring 的核心思想是什么？请解释 Spring IOC 和 AOP 的原理。

题目38

1、自我介绍
2、实习+实验室项目。广告平台对算法调用比较多，细问了我数据集的制作。然后就是挑一个实习项目的难点介绍。中间主要穿插一些选型的询问，kafka or rocketmq，以及消息队列的高可用，保证消息的不丢失等问题。
3、八股：
a、讲讲java里面线程同步有哪几种方式
b、java的synchronized是如何实现的，是不是可重入的，如何实现可重入
c、你对栈和队列的理解
d、如何用栈实现队列，实现一个容量为n的队列，至少需要的栈大小为多少。

题目39

问了项目的redis相关的数据用什么类型存的(问的很细，但是我没复习项目，忘了)
怎么保证mysql跟redis的一致性(答了先更新后删除)，问redis删除失败怎么办(答了设置ttl)
java是怎么保证线程安全的？有哪些工具？
介绍下CocurrentHashMap。jdk1.8之后有什么不一样？插入元素的具体过程？为什么要使用红黑树？红黑树的增加元素的时间复杂度？
ConcurrentHashMap如何返回size的？如果不了解说一下设计思路(答了维护一个原子变量)
sql的慢查询如何优化，可能优化的方案尽可能说出来(explain先看看执行策略，之后分为sql语句方面，索引优化方面，innodb方面，架构方面优化)
如果一个接口响应时间不符合预期，怎么排查跟解决？(增加cpu，增加实例并使用合理的负载均衡算法，优化代码逻辑，使用多线程处理并设置合理的拒绝策略，降级，限流，改造成异步接口，使用消息队列balabala能想到的都说了，属于是梦到啥就说啥了)

题目40

\1. 先做个自我介绍吧。

\2. 聊聊你的实习经历，我可能会问得比较细。

\3. Redis 底层有哪些数据结构？原理是啥？

\4. 怎么保证 MySQL 和 Redis 的数据一致性？

\5. 如果不用事务，怎么维护数据一致性？

\6. Redis 有哪些缓存淘汰策略？

\7. 数据库索引为什么用 B+ 树，而不是红黑树？

\8. 聊聊乐观锁和悲观锁的应用场景。

\9. 做秒杀系统的性能测试，主要关注哪些指标？

\10. RabbitMQ 的核心概念和工作机制是怎样的？

\11. 用 RabbitMQ 保证 Redis 和 MySQL 的数据一致性，要注意什么？

\12. 怎么给共享单车系统设计测试用例？

\13. 支付流程的测试用例，你觉得还能怎么补充？

\14. 怎么监控和优化慢 SQL？

\15. 介绍下常见的大语言模型（LLM）？

\16. 讲讲 Agent 技术的原理？

\17. 分享下你是怎么学习 AI 的？

题目41

\1. 订单表分库分表后，怎么同时支持按商家和美团订单号查询，避免读扩散？

\2. 了解分布式事务吗？聊聊 2PC、3PC、Seata、TCC？

\3. 这些分布式事务方案有什么缺点？怎么解决？

\4. 还有别的分布式事务解决方案吗？

\5. 了解分布式链路追踪吗？Trace ID 是怎么传的？

\6. ThreadLocal 的原理是啥？

\7. 还知道哪些 ThreadLocal 的变种实现？

\8. 这些变变体分别解决了什么问题？为什么会出现？

\9. 看过 Redisson 分- 布式锁的源码吗？底层怎么实现的？

\10. Redisson 的分布式限流和延迟队列是怎么做的？

\11. 了解 JVM 的 G1 垃圾回收器吗？

\12. 聊聊实习经历吧。

\13. 算法：反转链表。

\14. 平时怎么学新技术？实习遇到困难怎么解决的？

题目42

1、公式化自我介绍
2、公式化拷打实习，问难点在哪，你做了什么工作，为什么要这么设计
3、RateLimiter原理是什么？（实习相关）
4、介绍一下ConcurrentHashMap的原理，如何做到高并发的？
5、ConcurrentHashMap如何扩容的？
6、公式化问项目（黑马点评），如何解决session不共享问题的，token生成策略是什么？如何刷新token
7、介绍一下ZSet，答了ziplist、listpack和跳表
8、为什么mysql不使用跳表作为数据结构？
9、3行的B+树最多有多少个结点？（没答出来）
10、mysql的存储引擎有哪些， 答了innodb和myisam
11、innodb和myisam的区别
12、MVCC介绍一下（上一个问题提了一嘴就问了）
13、平时用ai吗？（发现最近美团很喜欢问这个。。。）我答了平时用ai帮我做一些DTO、VO转换、list转为map这种，但是面试官好像希望能用ai做一个需求而非这种辅助功能

题目43

. 先做个自我介绍吧。

\2. 聊聊你对 MCP 的理解？

\3. MCP 客户端怎么调用服务器上的工具？整个交互流程是怎样的？

\4. Spring AI Alibaba Graph 的底层原理是啥？

\5. AI 编程对你的工作或生活有影响吗？具体聊聊？

\6. 为啥要用线程池？

\7. Java 线程池有哪几种创建方式？

\8. Java 线程池都有哪些拒绝策略？

\9. 多线程编程怎么保证线程安全？

\10. synchronized 和 ReentrantLock 有啥区别？

\11. ReentrantLock 的底层原理是啥？

\12. AQS 是怎么实现的？如何保证 state 变量的原子性？

\13. 垃圾回收算法有哪些？

\14. 聊聊一个对象在 JVM 里的生命周期？

\15. JVM 新生代里的 S0/S1 区有啥用？对象什么时候会进入老年代？

\16. Kafka 有什么特点？和 RabbitMQ 有啥区别？

\17. Kafka 为什么吞吐量这么高？

\18. 大模型为什么会产生幻觉？有什么解决办法？

\19. RAG 具体是怎么实现的？

\20. 预训练和微调有什么区别？

\21. 我们来回顾一下你之前做的 AI 编程题。

题目44

. 面试官自我介绍，介绍部门，业务等
\2. 自我介绍（公式化）

\3. 介绍一下实习项目（开始介绍，着重说了一下项目中邮件推送功能，介绍自己实习产出）

\4. 你说项目中用到了分布式id？说一下常见分布式id
答: 时间戳，uuid，雪花算法，我说项目中用的雪花算法。

\5. 说一下雪花算法具体怎么实现的
答: 说的时候有点紧张，不过说清楚了雪花id根据每秒时间生成保证的有序性。

\6. 项目用到了jwt？说说jwt。
答: 介绍了一下jwt的结构，然后项目中使用redis存储token，介绍的时候我顺便说了一下token双刷，token黑名单等。

\7. 说一下threadlocal原理（我简历里没写，被问到了，不过幸好八股记得还算全）
答: threadlocal的key是弱引用，必须手动释放，否则会有内存泄漏，应用场景:一个线程内传递参数，可以减少实际方法中的参数传递。等等

————-玩具项目拷打环节（xfg的拼团)———-

\8. 你说项目中用到了规则树是吧，讲解一下具体怎么实现。
答: 这里差点忘了，玩具项目好久没看了，说了一堆，勉强圆回来了。

\9. redis的bitmap具体怎么来做人群过滤的？说一下bitmap。
答: 公式化bitmap八股，然后说的时候结合一些经典场景说了一下用户过滤。

\10. 责任链模板讲一下，具体怎么做的？
答 : 依旧结合场景，靠当时做项目的回忆来答。（感觉这个项目还需要再复习一下，问的还挺多的）

———-实习项目二次拷打———

\11. 消息队列的可靠性怎么保证？重复消费，顺序消费

答: 公式化消息队列八股，消息重试、唯一id、消费者确认、生产者确认、死信队列等等等等（开始吟唱）

\12. 重点讲讲你实习中消息推送这个功能吧，为什么要用rpc和消息队列？

答: 这个实习时候确实做过，所以答的挺顺畅。

\13. 场景设计题目: 如果现在我们需要对接很多个第三方支付的功能，比如微信，支付宝等，但是具体实现要分离开，同时我还要在每个支付功能的具体实现前后添加内容。请问上述场景的话，让你设计，你会用几种设计模式实现呢？

答: 首先可以使用策略模式，类比实习项目中使用策略模式对接不同的第三方邮件发送服务，
然后的话要在每个具体支付功能前后加代码的话，可以使用代理模式来进行添加

\14. 追问: 策略模式一般搭配什么模式使用呢？
没答出来，面试官提示工厂模式。

\15. 你项目中提到了做了慢查询sql的优化？你来说说定位慢查询，排查的整个流程。

答: 首先查询全局变量查看慢查询是否开启，同时根据获取到的日志路径，通过mysqldumpslow查看日志，找到日志问题，实际执行的时候可以使用explain关键字查看，后面就说索引失效、回表、实际执行语句时不能用函数等等。

答到这里其实答的都很好，后面面试官问了几个java基础问题（这里太久没看，模糊了），答得一坨，想找个地缝钻进去。

\16. 说一下访问修饰符
答: 一共四种，答了private，public，protected和各
最后我把默认的没有修饰符的情况漏了，说一下各自作用域，没答出来没有修饰符的情况的作用域。

\17. 说一下runtimeException和普通异常的区别。
答: 脑子蒙住了，没答出来。后面面试官说runtime会导致编译不通过，其他的话，抛出的话不会影响。

\18. java8的stream流了解吗，list通过stream转为map该怎么写，说一下。

答: 又蒙了，忘了这个api了。只说了一下.stream().filter()，后面的记不太清楚了。

题目45

自我介绍
实习经历（20多分钟）
八股（10几分钟）
hashmap
怎么实现一个线程安全的hashmap
Hashtable是怎么实现的？
concurrenthashmap呢？
jvm内存结构
Java线程状态
error和execption区别

二面

题目1

1.问了两句学校的项目，不是后端的，面试官肉眼可见没有兴趣

2.问了问实习做的rag项目的情况，不拷打纯聊天15分钟

3.RAG技术发展历史

4.java项目相关细节问题，比较常规：雪花算法，基因法分表，redis和db的一致性，缓存击穿

5.手撕

6.聊天室系统设计20min，业务实现orm设计、数据库设计、分库分表、restful接口设计

7.平时怎么学习，职业定位规划

题目2

主要聊了实习，还有 JDK 8 升 21 碰到的问题。

问了 UDP 广播。

场景题：微博大 V 发帖，用户量巨大，怎么优化？

问项目是不是自己写的，还问了分布式事务。

计网方面问了拥塞控制。

问了 JVM，怎么把元空间塞满？

问了些 Docker 的细节。

问了 Redis 的 Bitmap。

问了垃圾回收器。

问了怎么用大模型。

题目3

\1. 面试官介绍自己业务，没太听懂，说了有tob的也有toc的，主要是分布式场景、三高、数据一致性
\2. 自我介绍
\3. 项目经典点评超卖 + 一人一单一直说
\4. redission的setnx和redis的setnx有什么区别（不知道）
\5. 看门狗说说怎么回事
\6. rabbitmq消息积压怎么办
\7. 分析sql执行流程，innodb 字段(id,a,b,c,d) 索引有(d)、(a,b,c,d) select * from table_A where a = 1 and b = 2 and d = 4

SQL查询所有课程成绩都小于60分的学生学号、姓名，这里也宕机了一下
算法完成所有任务的最少初始时间

题目4

1.base偏好 业务偏好?北上杭各种业务都持开放态度

2.实习最大收获?项目中难点?怎么学习解决的? 提到了看技术博客和暑期面试美团的时候看的美团的文章，又问我一次为什么暑期没来美团

3.转正怎么样?是偏向于转正还是偏向于去外面找机会?(这时肯定得说老东家不好了

3.项目里MQ怎么用的?RocketMQ底层? 和 Kafka区别?

4.什么场景下选 Kafka?

5.实习用 redis是怎么用的?有没有看过它对数据库压力缓解了多少?(这是真没有)

6.为什么前端转后端?

7.想做全栈吗?

8.有什么 AI应用的实践?

9.AI Coding的时候有什么自己的rule?

10.数据库表数据量大了怎么办?主从不一致怎么办? 如何补偿?

题目5

\2. 中断运行中的线程有哪些方式
\3. 如何中断线程池中一个特定的任务
\4. 主线程如何感知子线程有异常
\5. ThreadLocal 的实现原理是什么？它为什么会导致内存泄露？
\6. LinkedHashMap 或 TreeMap 的数据结构是什么？（选一）
\7. TreeMap 的查找复杂度是多少？
\8. 一条 SQL 语句在数据库中是怎么执行的？（从 Client, Server, Engine 协作关系角度）
\9. ORDER BY 语句在执行过程中是如何实现的？
\10. SQL 题：三张表（学生、课程、成绩），如何查到数学成绩排名第二的学生？
\11. 用过哪些大模型相关的能力或技术？
\12. Function Call, MCP, Agent2Agent 之间的关系是什么？
\13. 你理解大模型出现幻觉的原因是什么？

题目6

介绍 rpc?rpc 和 http 最本质的区别（提示我是代理）

介绍 java 代理？java 的这两种代理（jdk和 cglib）能代理私有方法吗？

实现分布式锁除了 redis 还有哪些？答了 mysql 和 zookeeper

zookeeper和 redis 实现分布式锁最主要的区别（又和我解释你介绍这两个组件的区别也行）？

Redis 为什么快？

讲讲io多路复用？

Redis 数据类型？讲讲跳表？

米哈游

一面

题目1

1. 自我介绍
2. 实习经历
3. MongoDB和MySQL选型上有过考量吗
4. Redis分布式锁
5. Redis怎么做消息队列，可以使用什么数据结构
6. 怎么用Redis的数据结构实现一个延迟消息队列
7. 项目经历，页面查询优化怎么做
8. 游标和offset limit
9. 订单数据同步的数据一致性怎么体现
10. Redis在这里的作用
11. MySQL的事务隔离级别
12. MySQL三种日志
13. 二阶段提交

饿了么

一面

题目1

你用了优先队列（Priority Queue），这种做法本质上属于哪类排序？

该算法的时间复杂度和空间复杂度各是多少？

除了优先队列＋虚拟节点方案，你有没有想到其他更优解？

对“基本有序”数组，哪种排序最优？为什么？

请讲解快速排序的核心思想与流程。

如何快速从无序数组中找出第K大的元素？（如第3大、第10000大等）

最优解可否用堆？可否用快速选择（Quickselect）？

用3–5分钟重点介绍一个你参与度高、技术含量突出的项目。

你了解哪些开源RPC框架？

请详细讲一下阿里Dubbo的注册／发现机制、核心功能及优缺点。

令牌桶限流原理是什么？关键点在哪里？

你还知道哪些限流策略（固定窗口、滑动窗口、漏桶等），它们各自优缺点是什么？

你对Spring源码做过哪些研读？关注了哪些模块？

在Spring MVC中，IOC容器的两个最核心职责是什么？

能否详细讲解Spring容器的启动、类加载、Bean定义解析、依赖注入全过程？

JVM类加载双亲委派流程是怎样的？如何打破它？

请描述Java内存区域：堆、栈、方法区（永久代/元空间）、本地方法栈等。

哪些区域可能抛出OutOfMemoryError？

为什么Java 8将永久代改为元空间？它们在内存上的区别与优劣？

为什么要把String设计为不可变？

StringBuilder与StringBuffer有何区别？

反射的优点和缺点有哪些？

携程

一面

题目1

2.项目拷打

a.把项目部署在服务器上你会怎么做？

b.把项目进行打包要打包成哪几个部分？怎么进行打包？前端后端分哪几个部分？

c.跨域问题怎么解决？

d.实时私聊功能怎么做的？

e.假如一下子有大量消息的话，服务端要怎么保证消息转发的实时性和完整性？

1. MySQL索引的原理？
2. B+树和B树的区别？
3. Redis怎么实现分布式锁？
4. Redis在应对高并发请求场景下有什么应对策略？（一开始说了搭建集群来做分流，后面面试官提示说要从令牌桶技术限流角度出发）

题目2

1.自我介绍
2.实习相关项目介绍
3.数据库慢查询，如果走了索引还慢是什么原因
4.B+树的优缺点
5.你项目中用到了senta，介绍一下（吟唱分布式事务）
6.缓存如何实现一致性的
7.介绍限流方法和如何压力测试的
8.介绍下Elasticsearch，Elasticsearch底层是如何存储的
9.介绍下volatile
10.为什么要进行指令重排序（讲了CPU利用率，面试官评价应该从流水线讲起）
11.DCL单例模式太麻烦了，介绍下更适用的单例模式（讲了枚举，面试官说静态内部类用的更多）
12.栈中能存对象吗（回答只存引用地址，面试官说可以了解下逃逸原理）
13.知道对象头吗（直接展开到synchronized锁升级，面试官说其实已经不用偏向锁了）
14.jvm垃圾回收
15.jvm调优
16.生产环境CPU飚高如何解决

二面

题目1

1.自我介绍
2.介绍下实习项目和比较难的点
3.如何设计一个秒杀系统
4.解决超卖问题的方法
5.在数据库层面没有什么好的解决方法吗
6.幂等如何实现的
7.介绍下垃圾回收，讲讲full gc
8.分库分表你认为该如何进行划分，谈谈你的理解
9.MQ如何实现消息的顺序性
10.水平分表后应该解决哪些问题

小米

一面

题目1

1. 开场做了自我介绍，并详细介绍了项目经历
2. 聊聊你对Java集合框架的理解吧。ConcurrentHashMap在1.7和1.8里有啥不一样的地方？
3. Java内存模型（JMM）能介绍一下吗？GC这块呢，讲讲内存回收？对了，逃逸分析了解不？
4. Java并发编程里的锁，你是怎么理解的？CAS底层是怎么实现的，能说说吗？
5. 拦截器（Interceptor）和过滤器（Filter），它俩有啥主要区别？
6. SQL里 COUNT(*)、COUNT(1) 和 COUNT(具体列名)，它们之间有什么区别？
7. 用Redis做延时消息，有什么实现方案吗？
8. HTTPS的加密和认证流程，还能想起来吗？能详细讲讲这个过程不？
9. 假如有个特别大的日志文件，在Linux环境下，你会用什么命令去看它的内容？

题目2

1、介绍一下项目，延迟任务怎么做的

2、zset底层原理 为什么用跳表 最差情况下查询复杂度 和其他二叉树、红黑树区别

3、异步任务是怎么做的

4、IOC

5、介绍CAS

6、怎么用的多线程？ 什么场景考虑用线程池

7、熟悉的垃圾回收器

8、说一下Redission 面试官说底层都是setnx

9、Redis是单线程的？ 多线程体现在哪里

10、synchronized可用在哪里？ 场景：在一个类中的读写锁方法加上synchronized

11、Mysql 索引，你项目中哪些表用了什么索引？ 索引失效的场景？ 大于小于为什么能造成索引失效

12、Mysql ACID Mysql的几个隔离级别 可重复读和读已提交相比？

可重复读主要解决了隔离性

13、MVCC了解吗

14、聊一下网络 TCP和UCP区别

15、UDP优点 （快）

16、TCP建立连接

17、TCP断开连接 为什么需要等待2MSL

18、进行服务发现和负载均衡， 负载均衡算法是什么 是定制的？还是用的轮询

阿里

一面

题目1

1.优惠卷秒杀模块的技术亮点

2.处理线程安全问题的锁分为哪几类，一般是怎么使用的

3.介绍一下偏向锁和自旋锁

4.说一说你了解的加密算法

5.聊一聊你所了解的缓存

6.缓存一致性问题

7.在读取缓存时可能出现的相关问题

8.讲一下布隆过滤器的特点

9.布隆过滤器存在的假阳性的问题怎么进行优化

10.分布式系统的设计考量

11.分布式锁的大概原理

12.微服务的工作流程

13.微服务的服务数量很多的情况下如果某一个服务突然挂掉了可能引发微服务的雪崩，该怎么解决

14.限流算法的了解

15.CAS和AQS的原理

题目2

\1. 聊聊 Java 线程池的参数？线程池是怎么执行任务的？

\2. 建 MySQL 索引时要考虑啥？用 MySQL 的时候，要关注哪些指标？

\3. Redis 是怎么做持久化的？

\4. 对 AI 了解多少？了解 Milvus 吗？(这块我讲了一堆理论，但面试官没怎么追问)

\5. JVM 垃圾回收有哪些算法？CMS 和 G1 有啥区别？

\6. 为啥要用分布式锁？什么场景下会用？

\7. 讲一个项目里解决问题的经历？

\8. 你平时是怎么学新东西的？

题目3

1.自我介绍
先问的八股
2.简单描述一下常用集合类的适用场景及线程安全性
3.ArrayList 和 HashMap的增删改查复杂度
4.ReentrantLock 和 synchronized的区别
reentrantLock 的尝试机制忘了说了
5.mysql 事务
6.举个幻读的例子
7.mysql中建索引要注意什么
8.举个例子说明下什么是回表
9.如何避免回表
10.分库分表问题
面试官提示 : 尽量打散 结合业务需求分表
11.缓存雪崩击穿穿透问题

题目4

自我介绍

讲实习 35min
toc场景如何确保DB和REDIS尽量实时？
怎么避免缓存雪崩和击穿？
假如列表查询时数据量极大需要分页怎么办？

八股 10分钟
hashset讲一下
threadlocal讲一下

场景15分钟
设计一个智能会议总结系统
大致流程是前端把语音发到后端，调用工具转文字，调用大模型进行总结，再发回前端

题目5

\1. 为什么要使用CompletableFuture
\2. 线程池是怎么管理的
\3. 实习经历
\4. 本地缓存相关
\5. ThreadLocal内存泄漏
\6. HashSet为什么能去重
\7. Redis怎么保证原子性
\8. 缓存击穿和缓存雪崩
\9. 慢SQL优化
\10. 场景题：1. 前端录音 → 后端接收录音 → 后端调用阿里云API转文字 → 利用文字调用大模型API总结 → 文字落库

1. 前端调用后端接口输出文字

题目6

1、自我介绍

2、实习询问（5min）

3、项目拷打（20min）

4、谈谈 Java 的 HashMap

5、线程池的核心参数

6、线程池从没有任务到繁忙起来，再到空闲这个过程中，参数是如何变化的？

7、谈谈浅拷贝和深拷贝的区别

8、谈谈 Java 的 String 是怎样的结构？内部怎么设计的？

9、String 类在加载后会存在什么区域？

10、谈谈 JVM 的内存模型

11、GC 算法有哪些？每种算法应用在什么场景？

12、谈谈 CMS 垃圾回收器的回收过程

13、CMS 在哪些阶段会 Stop The World？

14、谈谈 G1 和 CMS 的区别

15、如何排查 OOM 问题？

16、如何排查 CPU 100% 问题？

17、日常开发过程中对于类冲突或者 jar 包冲突，如何去解决？（加载第三方包，和自己的环境不适配）

18、MySQL 怎么去排查慢 SQL？

19、谈谈 MySQL 的 InnoDB 存储引擎的索引结构

20、为什么 InnoDB 不选择 B 树或者红黑树？

21、MySQL 的排序 order by，对于大数据的排序，是怎么实现的？

22、目前对于 AI相关的一些前沿的技术自己有去了解过吗？

23、你认为对于数据标注类工作，比如判断一张图片有无水印，能否用 AI 去代替人工？

题目7

1.自我介绍

2.实习经历中有哪些亮点。

3.个人项目有哪些技术难点。

4.秒杀系统的流量承接怎么做的。

5.如何解决超卖问题（多种实现）。

6.系统如何防刷的。

7.GC如何设计的。（内存结构到回收算法）

8.mysql 行锁的加锁过程。

9.TCP可靠性，滑动窗口解决了哪些问题。

10.AI方面关注过哪些技术点。

11.简单聊聊LangChain和LangGraph。

题目8

1,现在在哪实习
2，有没有转正
3，那你现在更倾向去哪
4，挑一个项目讲讲
5，怎么解决大key以及数据倾斜问题
6，redis分片后本身有什么联系
7，数据倾斜解决用什么算法
8.整体业务是什么，为什么设计这四个缓存
9，实习遇到难的问题
10，复现哪些是比较难的，怎么复现
11，为啥忽然换实习
12，另一个项目介绍
13，第一个功能怎么实现的
14，怎么做的健康检查
15，什么时间间隔发请求，还是怎么做的
16，这个功能支持什么协议，一般用什么协议，不同协议的使用场景（后面再看看有点忘了）
17，健康请求，需要触发吗，还是有定时任务
18，你这里面怎么样递归
19，什么时候订阅，哪些节点订阅
20，什么时候初始化启动
21，怎么初始化，什么时候订阅消息初始化
22，建立长链接还是短连接
23，什么时候用长连接，什么时候用短连接
24，你那个开关经常变化吗，
25，你这个ectd为什么用长连接，而不是短连接
26，介绍你的研究方向
27，你这个方向具体解决什么问题
28，解决思路什么
29，最后的效果如何，为什么能达成这样的效果
30，平时怎么样学习
31，展开讲讲你的学过的一次技术分享
32，为什么不找你研究方向相关的工作
33，你觉得开发具体往哪个方向发展会更好，提到大模型智能体什么的
34，你为什么不找智能体相关的工作
35，讲一下反射原理，应用场景，实际工作中的应用
36，并发编程主要用来干嘛

题目9

1.concurrenthashmap怎么保证线程安全

2.hashtable线程安全(不会

3.hashmap线程不安全例子(说的不咋地

4.Future用过吗(没有

5.Spring ioc底层 好处

6.mysql索引 联合索引的B+树具体咋实现的

7.mysgl隔离级别 RR用在哪些场景

8.5层网络模型tcp udp区别http https区别

9.阿里云有哪些产品用的udp?(这我哪了解过

10.死锁条件(忘了一个

11.A给B转账 B给A转账会死锁吗?12.微软实习13.阿里云实习

14.手写支付系统A给B转账(没写完讲了思路，具体问了怎么加锁

15.RocketMQ事务消息底层实现，回查时间16.如果事务回查的时候事务那个线程在执行逻辑 超过回查时间事务回查到成功会有什么问题?怎么解决?(没太理解他的意思

腾讯

一面

题目1

1. 实习干的东西

2. 权限管控怎么做的

3. 权限管控是怎么标识的用户

4. 怎么保证用户信息不会被传输过程篡改

5. https怎么保证的加密传输

6. 线程和进程的区别 进程能访问其他应用的内存吗 为什么

7. 线程和协程的区别

8. 项目里为什么要使用登录 qq登录怎么做的 过程是怎样的 qq是怎么加密的中间数据

题目2

Canal 和 Kafka 之间是怎么交互的？用的什么协议？
Kafka 的实现原理是啥？
ES 为什么这么快？讲讲倒排索引，还有文档列表是啥意思？
资源隔离是怎么实现的？
K8s 的部署和滚动更新流程是怎样的？怎么在更新的时候保证服务不中断？
有个下载文件的问题（具体忘了）
操作系统启动时都干了些啥？
聊聊操作系统的内存管理和进程管理？
给你一大堆 IP 地址，怎么找出哪个网段下的 IP 最多？
我答了个 O(n) 的方案，面试官追问怎么避免哈希冲突，有没有更好的方法，还问了哈希冲突最极端的情况怎么办。
又追问，如果想找 Top 3 怎么办？要是内存不够，又该怎么找 Top 10？

题目3

1. 自我介绍
2. 开篇面试官介绍了一下这次面试的流程
3. HashMap和HashTable的区别？
4. 接T3，针对HashTable的问题，有没有解决方案？（ConcurrentHashMap）
5. 线程和进程的区别？
6. 接T5，通信方式上有什么区别？
7. MySQL索引结构？
8. 接T7，B树和B+树的区别是什么？
9. 接T8，为什么说B+树更好做范围查询？
10. MySQL事务隔离级别？
11. MVCC
12. 索引失效的情况都有哪些？
13. Redis持久化方案？
14. 缓存雪崩、缓存穿透、缓存击穿
15. 讲讲TCP的三次握手和四次挥手
16. 说说Linux的常用命令？
17. 有没有用过Docker？说说Docker的常用命令？有自己构建过Docker镜像吗？

题目4

你对腾讯云智的产品有哪些了解？有没有使用过相关的服务？
Java 中的集合框架有哪些？HashMap 和 ConcurrentHashMap 的区别是什么？
谈谈 Java 中的多线程，线程池的核心参数有哪些？如何设置合理的线程池参数？
Spring IoC 和 AOP 的原理是什么？在项目中是如何使用 AOP 的？
Spring 事务的传播机制有哪些？你在实际开发中遇到过哪些事务相关的问题
Java 中 synchronized 和 Lock 的底层实现原理有何区别？谈谈你对偏向锁、轻量级锁、重量级锁的理解
深入分析 ThreadLocal 的内存泄漏问题，如何避免？在分布式场景下如何实现类似 ThreadLocal 的功能？
Redis 的持久化机制有哪些？RDB 和 AOF 的优缺点及适用场景是什么？如何解决 AOF 重写时的性能问题？
Redis 的集群方案有哪些？哨兵模式和 Cluster 模式的区别是什么？Cluster 模式下槽位迁移的过程是怎样的？
RabbitMQ 的交换机类型有哪些？详细说明 Topic 交换机的路由规则，如何保证消息的可靠性投递（从生产者到交换机、交换机到队列、消费者消费三个环节分析）
单例模式的实现方式有哪些？哪种方式是线程安全的？
在项目开发中，你是如何进行代码调试和排错的？有什么技巧吗？
工厂模式和抽象工厂模式的区别是什么？在什么场景下会使用抽象工厂模式？
工厂模式在实际项目中有哪些应用？你觉得使用工厂模式有什么好处？
Java 中的异常处理机制是怎样的？try-catch-finally 块的执行顺序是什么？
谈谈你对 Java 内存模型的理解，volatile 关键字的作用是什么？
数据库的分库分表有哪些方案？各自的优缺点是什么？
在进行 Java 开发时，你是如何保证代码质量的？会使用哪些工具？

题目5

1.自我介绍
2.5层网络分别是什么，讲讲每层什么协议，有什么东西
3.MTU包含哪些层的数据，大小一般多大怎么计算
4.MTU和MSS区别
5.TCP怎么保证可靠的
6.建连和断连是怎么样
7.为什么挥手四次要比握手多一次
8.挥手并不是一定得四次，能在更少次数内实现，请分析可能怎么做的
9.既然能挥手次数更少，但是为什么现在主流还是四次
10.我假设是一个客户端，我在和服务端通信，我怎么知道发送窗口数据量是多大呢
11.现在已经有了一个滑动窗口了，这个滑动窗口大小变化的时候是怎么变化的
12.我丢包了，那这个窗口大小是不是就有问题了，有什么处理方案
13.你作为一个一端的程序，是怎么知道是网络拥塞还是是链路丢包的
14.TCP的拥塞控制是怎么做的
15.假设要让你设计一个完整的判断网络拥塞还是链路丢包的协议，你会怎么设计
16.现在假设你打开腾讯视频，突然某些（不是所有）视频你看不了了，你会怎么分析+排查+定位+解决这个问题，从app端上的问题-》网络的问题-》服务端的问题各个角度尽量全面的分析
17.wireshark你了解吗，怎么在手机上抓包呢
18.算了你假设你能在手机上抓包，你怎么从二进制数据排查定位分析这个场景的问题原因呢
19.抓包的底层原理是怎么样的，这个包是怎么从操作系统的内核态数据取到的
20.HTTP1-3对比，讲讲多路复用在内核是怎么实现的
21.QUIC保证udp可靠传输和tcp自身可靠传输的对比
22.HTTP和HTTPS区别
23.你讲讲HTTPS的完整的方案
24.你这种方案的RTT是多少
25.有1RTT的HTTPS方案，你了解吗
26.你对网络安全了解多少，像DDOS攻击，中间人攻击这些了解吗，有没有一些解决

题目6

~ tcp客户端开发有哪些步骤

~ tco协议具体是什么

~ 描述三次握手和四次挥手

~ udp一个包有多少数据

~ 结构体和模板类的区别是什么

~ linux根目录proc目录作用是什么

~ 介绍一些调试工具

~ mysql引擎是什么

~ ddos是什么

~ redis有哪些数据结构

~ redis缓存慢了怎么办，如何进行持久化

~ 消息队列

~ 举一些agent框架

~ mcp是什么

~ mcp用的通信协议

题目7

\1. 自我介绍后问意向base（刚开始还抱有期待hhh）

\2. 介绍实习内容？有什么难点？

\3. 你说的这些偏业务，有没有技术上的难点？

\4. 你提到redis，zset底层原理？dict和skiplist是怎么对应的？如果让你设计，如何设计一个并发安全的跳表？

\5. 内存里有一个map，你如何设计持久化策略，使得忽然宕机时，能够保证数据最少丢失？

\6. 假设redis有一个list，客户端执行append操作，你如何设计，实现能够判断插入失败的原因（client还是server导致的）

\7. 100g数据1g内存找中位数？

二面

题目1

1. 自我介绍

2. 有用过MQ对吧，那你说说怎么解决消息重传的？

3. 你是怎么做消息幂等性处理的？

4. 接T3，如果说Redis的key已经存入了，但是刚好消费者宕机了，怎么办？

5. 建立索引的SQL语句是？

6. TLS握手过程

7. 手撕1：单链表有一个指针指向任意一个节点，怎么删除这个指针指向的节点，如1→2→3→4，传入2，删除2，没有头指针（回答了更改节点值，next设置为next.next，追问怎么删除最后一个节点，不会，换了道题）

三面

题目1

1. 自我介绍
2. 拷打项目
3. 拷打实习
4. 我现在有一个student表，我要对name简历索引，sql语句怎么写？
5. 主键索引和普通索引有什么区别？
6. 为什么非聚簇索引要回表？
7. MySQL隔离级别？
8. MySQL主从同步原理？
9. binlog日志存的是什么？
10. Redis缓存雪崩是个什么概念？怎么解决？
11. Redis持久化方式？
12. HTTP报文格式？
13. HTTP和HTTPS有什么不同？
14. TLS握手过程？
15. 为什么是非对称加密和对称加密结合使用？能不能只使用一种？
16. 面向对象三大特性
17. 我现在有一个Java源代码，比如说叫xxx.java，他是如何变成一个二进制文件的能够让机器运行他的？这个中间的过程是怎么样的？
18. JVM的作用是什么？
19. 进程和线程的区别？
20. 有没有了解过协程？跟线程的区别是什么？
21. 为什么说协程为什么更轻量？
22. 二进制文件加载进内存，他的分布是怎么样的？
23. Linux上怎么看机器的负载？
24. top命令哪些参数表示负载？
25. Linux怎么看cpu的核数？
26. Linux怎么查看当前目录占用了多少空间？
27. 查看当前服务器建立的tcp连接，用什么命令？
28. tcp滑动窗口机制是怎么样的？
29. time_wait状态是什么意思？
30. 为什么是四次挥手？
31. 三次握手是怎么实现的？中间的ACK和SYN是怎么合并的？
32. 用过docker吗？怎么做到容器间隔离的？
33. 怎么构建docker镜像？
34. 有了解AI吗？大模型训练过程是怎么样的？
35. 有没有了解过MCP？
36. 使用过什么AI工具？

中兴通讯

题目1

1、两段实习拷打，没手撕；

2、如果你想做出海业务你会想怎么去因地制宜设计架构；

3、redis大key对于cpu和网络流量的影响；

4、redis跳表结构；

5、mysql的b+树结构，mysql的FULLTEXT索引是否能帮助进行模糊查询，这个索引和es直接查询区别在哪；

6、sql语句执行顺序；

7、线程池原理；

8、Hashmap结构和扩容机制；

9、Java开发中用到的同步机制；

10、rpc调用链路中怎么保证分布式事务的最终一致性；

11、谈谈kafka怎么保证消费的一致性和顺序性还有可靠性；

12、说说gc收集器，说说怎么排查gc日志；

13、说说Java开发过程你用到的设计模式；

14、说说你简历写的慢sql排查思路；

15、死锁检查，银行家算法；

16、jvm结构；

17、JNA怎么保证不内存泄漏；

18、OOM常见情况；

19、linux大页；

20、拦截器和过滤器；

21、一致性协议还有相关的选举机制；

22、redis缓存雪崩穿透击穿场景和解决方法；

23、常见的哈希冲突，ThreadLocal怎么解决哈希冲突；

24、怎么优化提示词生成效果；

25、怎么写规则引擎；

26、你常用的设计模式；

27、类加载机制和双亲委派；

28、数据库三大范式；

29、2pc，3pc，tcc，seata；

30、最大堆最小堆是啥样子的，红黑树原理，堆排序过程。

科大讯飞

题目1

.自我介绍

2.问了一下实习的东西

3.问了一下Java中那些组件和技术学的好(我回答了Nacos,Sentinel,RocketMQ,Zookpper,Dubbo,Redis,Caffein这类的)

4.Java中的封装和反射的区别(这里建议回答为什么有封装了还需要使用反射,要更了解底层,比如要回答反射的一些作用,依赖注入这类的,要回答反射使用的一些例子(比如反射是用于动态代理,为什么是动态的?举例子),后面还问到了设计模式,我说到了代理模式(AOP),但是面试官说没有这种设计模式,最后说了一下工厂模式,但是没了解过工厂模式底层怎么使用到反射)

5.反射运行时灵活,怎么体现的?(最好说依据,举例子)

6.工厂模式底层怎么使用到反射,为什么这么使用

7.说一下Mysql的事务怎么实现的(我回答了锁)

8.Java里面有哪些锁

9.事务的特效(ACID)

10.说一下ACID是什么

11.你知道Redis也有事务,redis的事务跟Mysql的事务有什么区别(我不会)

12.问了一下毕业时间,有没有考研打算,说一下自己的职业规划,往什么方向发展,感兴趣什么,想从事什么职业

题目2

Java 有哪些基本的数据类型？

32 位操作系统跟 64 位系统 int 类型有区别吗？

讲一下 Java 的集合结构？

如何对集合的元素排序？JDK 里排序用的是什么算法？归并排序和快速排序有什么区别？

讲一下 JVM 的结构

引用计数法如何解决循环依赖？

JVM 有哪些垃圾回收算法？

MySQL 执行一条 select 语句经历了哪些？MySQL 有些存储引擎？

SpringMVC 中的过滤器跟拦截器有什么区别？

SpringBoot 从接收到一个请求到返回前端经历了哪些？

影石

题目1

1.自我介绍
2.介绍一下学校情况和学的语言和框架

1. 线程池的四种类型 ， 核心参数
   4.单线程池的应用场景
   5.同步的一些方式
   6.reentranLock和synchronized的区别
   7.各自怎么来进行同步过程，contional的sign()和await()；
   8.correntHashMap , copyonWrite
   9.ArrayList的扩容过程，复制过程是底层的system.copy();
   10.容器快速失败过程和原理（就是遍历的时候被修改）
   11.TCP和UDP的区别和各自应用场景

SOUL

一面

题目1

自我介绍
实习拷打：为什么用线程池，用了什么线程池？有什么指标吗？提升了多少？为什么用策略模式和工厂模式？还有哪些难点？
spring 的模块有哪些？
IOC， AOP，DI分别指什么？
spring bean生命周期
线程池有哪些优点，池化
mysql事务有哪些隔离级别
一条sql语句如何执行的
redis有哪些数据结构，使用场景
redis哨兵如何选举，
redis持久化机制

题目2

Java 的重写和重载有啥区别？

Spring Bean 的生命周期是怎样的？

Java 什么情况下会 Full GC？

手撕 SQL：查出学生数超过 3 个的学院。

慢查询怎么处理？

MVCC 是干嘛的？

不同隔离级别下，MVCC 的表现有啥不一样？

Redis 的持久化机制是啥？

AOF 重写是怎么回事？

git 提交错了怎么办？

操作系统里进程间通信有哪几种方式？

Linux 里怎么干掉一个进程？

Linux 怎么查进程 ID？

Redis 有哪些数据类型？

ZSet 底层是怎么实现的？

项目里有啥难点？(我聊了秒杀流程)

分布式锁是怎么实现的？

怎么知道分布式锁被哪个线程占着？

得物

一面

题目1

1.简历上后端经历偏多，为什么来投递我们IOS端？
2.实习经历简单介绍一下
3.面向对象的设计原理？
4.设计模式了解哪些？
5.进程和线程的区别？
6.为什么会产生死锁？
7.讲一下优先级反转？
8.多线程操作非原子的数据的安全性怎么保障？
9.自旋锁是什么？
10.想要复用别人开发的方法但其只能满足自己一部分需求，可以怎么做？
11.怎么设计一个易复用的代码结构？
12.如果定义成纯虚函数，原有的功能逻辑怎么办？

题目2

自我介绍

1.dubbo的spi和java的spi有什么区别

2.分布式系统中的trace链路跟踪

3.线上的java服务cpu负载高怎么排查
怎么定位是哪块的代码出了问题

4.分布式系统调用下游服务怎么保证成功
怎么去设计重试机制 异步线程池不会爆满吗

5.java里的类加载机制
双亲委派怎么打破
spi 是怎么打破的

6.jvm内存溢出怎么排查(堆内与堆外怎么排查)

题目3

1、跳表原理

2、跳表相对于平衡树在并发场景下有优势

3、CAS 三大问题，以及怎么解决

4、版本号AtomicStampedReference的怎么解决

5、线程池使用无界队列的问题

6、线程线程怎么结束的

7、事务的@Transtional 注解，A事务调用B事务抛出异常之后，在默认事务传播机制下，会提交异常，因为 rollback 异常标志位已经被设置有值

8、如果一个Trace 调用耗时比较长，怎么去进行排查

9、Redisson 的看门狗机制

10、Spring 是如何解决循环依赖的11、Kafka 落盘如何建立索引

题目4

\1. 讲一下redis zset底层数据结构，讲讲跳表、压缩列表、listpack？

\2. 从浏览器地址栏输入网址按下回车，发生了什么？

\3. 浏览器怎么知道你按下了回车？

\4. 应用程序怎么知道客户端向其发送了请求？

\5. 影响MySQL B+树高度的因素

\6. 讲一下MySQL执行查询语句的流程

\7. [项目] 如果别人拿到了sessionId，就可以冒名登录，如何解决这个问题？

\8. [项目]每次进行判题都创建容器，是否会有性能问题？

\9. [项目]用户规模大后怎么解决QPS高的问题？

题目5

\1. 简单说下最熟悉的中间件，或者说看过源码的中间件
\2. JVM内存模型
\3. 栈内存的生命周期是什么？
\4. 栈内存，也就是说虚拟机栈是什么时候创建的？
\5. 为什么栈是线程私有的？
\6. synchronized关键字知道吗？
\7. 锁标识存在哪里？
\8. 公平锁还是非公平锁？怎么实现的？
\9. mysql聚簇索引和非聚簇索引有什么区别？
\10. 空值会不会存入索引？查询会走索引码？selsect一个 null值不会全表扫描吗？
\11. Redis淘汰策略了解吗？
\12. Redis的LRU的数据结构是什么？怎么实现的？
\13. 二叉树层次遍历口述
\14. Redis什么情况下会造成阻塞？有什么使用不规范的情况会导致？（单线程角度）
\15. 设计一个火车票库存表，有哪些字段？
\16. 有一辆列车从北京到上海，中间站郑州，怎么存储这些车票？
\17. 如果中间站A，B，C…怎么存储？考虑中间站之间的上下车，比如B到C的票，一共该怎么存储？
\18. SQL：
查找下了最多订单的客户的 customer_number
表: Orders order_number customer_number
在 SQL 中，Order_number是该表的主键。
此表包含关于订单ID和客户ID的信息。
查找下了 最多订单 的客户的 customer_number
测试用例生成后，恰好有一个客户 比任何其他客户下了更多的订单。

题目6

1.自我介绍
2.实习/项目经历中有什么遇到过什么困难？
3.利用大模型进行代码的缺陷检测，你了解大模型底层是怎么做到输入代码返回缺陷的吗？
4.大模型应用方面有哪些调优的地方？
5.上面你提到需要提取一些上下文，比如全局变量，你知道java中哪些对象可以作为GCroot？
6.gc有哪些机制，能说说吗？（说了gc算法，gc垃圾回收器）
7.现在使用哪一种垃圾回收器? (jdk1.8默认的)
\8. 那和其他垃圾回收器相比，你使用的垃圾回收器有哪些优点与缺点？（其余的STW的时长会短一点，高并发、低延迟）
9.项目中有一个优惠券防超发的功能，说说怎么做的？
10.锁的维度是什么？
11.优惠券创建的时候就和用户做了绑定了吗？
12.那你按照用户id去锁（好像应该是锁优惠券），那多个用户去抢，怎么做到防止超发？（数据库乐观锁）
13.那为什么还需要锁用户id（防止单个用户去抢多张券）
14.锁的超时时间是怎么设置的？
15.使用消息队列进行异步领券，那如果消息还没有消费，用户又一次发了请求，怎么处理？（先校验再发送到MQ）
16.那如果消费队列消费失败了怎么办？（兜底，死信队列对失败消息处理，重试？回滚？）
17.你的分布式锁怎么控制死锁的情况？
18.数据库与redis的一致性如何去保证？
19.单例模式双重锁的那一套写一下？解释一下为什么要两次判断？
20.我看你加了volatile，有什么用？
21.java中有error和Exception两种，分别是什么？讲讲？

题目7

1.讲一下有挑战的项目

2.讲一下熟悉的中间件

3.讲一下jvm内存模型

4.栈的生命周期

5.栈什么时候创建（回答的不是很好）

6.栈和线程的关系（回答的不是很好）

7.java的sy锁

8.LRU的底层

9.讲一下二叉树层序遍历

10.手撕sql

11.场景题：火车票库存系统设计数据库字段

题目8

1、实习相关。Kafka生产端如何保证幂等性，重复发送到同一个Broker能否做到，生产端是否能做幂等处理。

Kafka中分区的leader选举策略有哪些，第一优先级是什么。

\2. Redis缓存相关：

- 问题区别与解决：Redis缓存穿透、击穿、雪崩的区别及对应解决方案。

- 击穿方案补充：针对缓存击穿，除了互斥锁还有其他解决方案吗；canal异步更新对击穿的作用。

- 互斥锁场景与弊端：互斥锁针对什么样的场景用比较好，其弊端是什么。

\4. Spring相关：询问Spring Bean的生命周期

题目9

1.你这边投的是开发吗？不是的话我们换一个面试官（可能看实习是测开）

2.自我介绍

3.二级缓存怎么实现的，数据一致性怎么保证

4.kfaka、rabbitMQ、RocketMQ三个的区别，为什么会选RocketMQ

5.消息队列的应用场景

6.普通消息、顺序消息的区别，在什么场景会用到

7.怎么保证消息的顺序消费

8.顺序消息会有什么缺点

9.如果顺序消息，有一条消息失败了会怎么样，怎么解决

10.SQL优化

11.B+树索引和ES倒排索引的区别（简历里没写es）

12.MySQL进行模糊匹配时，为什么效率低；为什么es会比较快

13.es还可以用来聚合，具体怎么实现的

14.什么是事务消息

15.事务消息和分布式事务中Seata的关系（不会）

16.线程池的核心参数以及任务到达后的一个处理逻辑

17.如何进行线程池调优

18.AQS

19.还有什么其他锁

20.乐观锁的实现原理及存在的问题

二面

题目1

\1. TCP 连接在什么时候会进入 TIME_WAIT 状态？

\2. HTTP 请求是怎么上传大文件的？

\3. Cookie、Session、Token 有什么区别？各自的优缺点是啥？

\4. MySQL 有哪些索引类型？什么情况下索引会失效？

\5. 更新数据时，怎么保证 Redis 和 MySQL 的数据一致性？应该先删缓存还是先更新数据库？这两种方式分别有什么问题，怎么解决？

\6. 详细介绍下几种限流算法。

\7. 令牌桶算法的令牌一般存在哪里？单机和分布式系统下有区别吗？

\8. 考几个 Linux 命令：

​ \1) 怎么找到当前目录以及所有子目录里，后缀是 .c 的文件？

​ \2) 怎么把一个 txt 文件里所有的 “abc” 字符串替换成 “cd”？

​ \3) 怎么打印一个 .log 日志文件里，最近 10 条包含 “error” 的日志？

滴滴

一面

题目1

1. 自我介绍。
2. (项目) 聊聊你们是怎么防止单点故障的？
3. (项目) 具体讲讲那 10 万条数据是怎么处理的？
4. 线程池有哪些核心参数？它具体是怎么跑的？
5. 线程池的核心参数，你一般都怎么设？特别是核心线程数和最大线程数。
6. synchronized 和 Lock 有啥区别？要是碰到异常，它俩分别会怎么样？
7. JVM 的运行时数据区都包含啥？分别介绍一下？
8. MQ 一般都用来干嘛？除了削峰填谷还能干啥？为啥要用 MQ？
9. MySQL 优化，除了加索引还有别的招吗？
10. 介绍下数据库的隔离级别？
11. 讲讲缓存穿透？怎么解决？布隆过滤器具体怎么实现的？有啥特点？
12. 手撕算法：10 万个数里找出最小的 10 个（用小顶堆）。
13. 以后有什么规划？

题目2

1、自我介绍，大概 2 分钟。

2、详细聊了聊项目，深挖了一些技术细节。

3、啥是序列化和反序列化？

后面还聊了：

- equals 和 == 的区别？

- ConcurrentHashMap 的原理？

- 线程池参数怎么配？

- CPU 密集型任务为啥线程数要设成 CPU 核数+1？

- 怎么平衡软硬件资源的使用？

- synchronized 的锁升级过程是啥？

4、JVM 垃圾回收：

- 详细讲讲垃圾回收算法？

- 主流的垃圾回收器有啥区别？

- 新生代和老年代用的回收算法有啥不一样？

- 新生代为啥用标记-复制算法？

5、深挖了项目里的调度系统。

6、详细聊了并发解析 Excel 的方案：

- 接口延迟怎么处理？

- 数据库表结构怎么设计的？

- 并发写入和限流策略？

- 权限验证机制？

- 怎么防重复提交？

- 数据合规性怎么校验？

题目3

\1. 看过源码吗，什么时候才会去看源码

\2. redission了解过吗，有什么用，怎么实现分布式锁的，原理是什么，为什么是可重入的，是怎么实现给锁续期的，他怎么检查任务是否执行完成了呢，轮训吗

\3. redis是怎么实现执行操作的原子性的

\4. mysql三个日志的作用和区别

\5. mysql事务隔离级别，默认的是哪一个，每个隔离级别会产生什么问题，分别是怎么解决的

\6. 有哪些线程安全的队列（回答阻塞队列和复制队列），阻塞队列有什么用，有用过吗

\7. sync锁和lock锁的区别

\8. lock的底层实现

三面

题目1

1.问了下实习内容
2.kafka能不能保证消息全局有序性
3.kafka如何将消息传给partition的，用的什么路由算法？
4.kafka的rebalance机制原理，新加入的consumer怎么重新分配partition的？
5.redis的动态字符串扩容机制？

题目2

\1. 没有考虑过留在之前实习过的公司吗？
\2. 你主要用的语言是 Java 还是 Go？Go 的底层你了解吗？
\3. 你过去哪一段项目是你觉得比较有挑战的？能具体聊聊吗？
\4. 要不先讲讲你现在在字节的项目？你介绍一下？
\5. 你做的这个 SDK 是在解决什么问题？什么叫同步/异步？
\6. 老系统和新系统，你们为什么要做迁移？老系统代码量和问题在哪里？
\7. 你总结一下你做的这个 SDK 的核心功能，能提炼为三点吗？
\8. 你的 SDK 是放在业务系统里的吗？
\9. 如果 SDK 需要升级，怎么推动所有调用方升级？
\10. 聊聊你在快手的项目，哪个部分最有挑战？
\11. 算法：两数之和
\12. 你为什么要用哈希表来做？和暴力循环 O(n²) 的方法相比，哈希表有什么好处？
\13. 如果数组有上千万的数据，你的哈希表能装得下吗？
\14. 如果内存放不下所有数据，你会怎么处理？（分块/落盘/分文件…）
\15. 有没有更高效的方案？
\16. 你的方法只能找到一组解，如果有多组解怎么办？
\17. 你觉得现在的 O(n) 算法还有优化的空间吗？
\18. 假设你在浏览器输入一个网站的 URL，然后点确认，到最后看到网站页面，中间发生了什么？
\19. HTTP 和 HTTPS 的区别是什么？HTTPS 的安全性是怎么保证的？
\20. HTTPS 的证书交换、加密解密的过程是怎么样的？
\21. HTTP/2 和 HTTP/1.1 有什么区别？HTTP/2 做了哪些优化？
\22. 你最近在看什么技术？对什么方向比较感兴趣？

猿辅导

一面

题目1

八股

• 进程之间的通信的方式？
• 线程同步的方式？
• 阻塞&非阻塞 和 同步&异步 都是什么？
• 数据库事务的 ACID 都是怎么实现的？
• 使用事务的时候都要注意什么？如何做死锁避免？
• 分布式保证一致性的 CAP 和 BASE 理论

项目

• 为什么要用 RAG？
• 有做过 prompt 攻击的防范吗？

题目2

自我介绍
项目询问
百度实习的qps、流量大小
怎么保证服务可用
怎么处理慢查询
介绍一下百度实习的技术难点
腾讯实习的一个core单子是怎么排查的
MIT6.824Lab里，如果切片迁移期间程序崩溃会怎么样
Lab怎么做的切片分配
怎么理解redis所谓的“单线程”
Redis作为缓存怎么保证一致性
Redis怎么持久化
场景题
一个超出内存限制的大文件怎么排序
了解过mapreduce吗
八股
介绍下golang的goroutine调度
goroutine遇到网络IO等阻塞事件会怎么样
介绍下golang的gc机制
你说gc需要stw，什么时候会暂停程序

百度

一面

题目1

1. Redis如何实现高可用

2. 跳表查找，删除时间复杂度

3. wal log断电如何解决

4. wg.Add() 和 wg.Add(1)区别是什么

5. wg里面，一个协程挂了，如何操作： 捕获panic，recover，发送错误，结束

6. 线程新建，切换的开销体现在哪里

题目2

反射是啥，那些地方使用了

equals和==的区别

重写equals要注意什么

ThreadLocal、数据结构、内存泄露

B树和B+有什么区别

联合索引是什么？什么情况下会失效

手撕SQL：我记得不难，一个group+order

线程池参数有哪些？平时怎么使用的？

线程池的submit和excute有什么区别

spring声明式事务如何用？什么时候失效？

死锁是什么？怎么避免

我们要缓存一个接口的结果，key要有方法名和参数，太大了怎么办

布隆过滤器是什么，数据结构、原理

缓存穿透和缓存雪崩

垃圾回收有哪些方法

JVM的分代收集介绍一下

快排的原理？是稳定排序吗？

git怎么使用？

Stream会用吗？

题目3

JMM Java内存模型

mysql 索引 有哪些

排序算法有哪些

linux命令 查看进程信息命令，查看端口命令

你知道哪些设计模式，分别举例说明

三次握手

生产者消费者

垃圾回收算法

抽象类，接口，普通类的区别

重载和重写

生产者消费者的原理和过程

题目4

进程和线程的区别

进程间的通讯方式

线程间的通讯方式，多个服务，单服务

Linux常见命令 ，搜索等

Linux通讯命令，通讯原理是什么

tcp三次握手，为什么必须要三次

hashmap底层原理，有哪些线程安全的map

答concurrenthashmap，问底层原理，怎么加锁的

springboot启动注解是什么，内部的四个实际注解讲一下

MySQL事务，事务特性。

深挖索引，联合索引，ABC BC AC 怎么走索引，索引下推是什么，索引优化查询命令各个字段讲一下

拷打实习，怎么加的索引，什么情况下索引失效，举例子，做什么业务，代码库是什么，怎么上线打包部署的，全程拷打真实性和个人收获，实习做的东西也都用上了，能和面试官聊起来，感觉加分挺多的。

做题 一道sql多表联合查询，一道算法

题目5

自我介绍
介绍一下实习项目
如何使用乐观锁解决超卖问题的
乐观锁和悲观锁的区别，介绍一下
redis缓存穿透、缓存击穿、缓存雪崩问题及解决方案
在高并发场景下设计一个点赞系统
使用redis存储点赞数据，数据库怎么存？何时落库，落库的时候是不是也要考虑分批
redis数据持久化方式及区别
介绍单例模式的两种实现及区别
简单工厂模式和工厂方法模式

题目6

1. 自我介绍
2. 实习拷打
3. 怎么对mysql进行优化
4. 怎么对十亿级别的线程和进程数据进行管理
5. 现在都是分布式系统，怎么保证我们获取的数据是最新的

题目7

1. 自我介绍
2. 知道这是测开不就投？-知道，不管了
3. 说一下你实习中的Redis缓存优化怎么做的
4. 你怎么去测试这个
5. 订单数据同步说一下
6. 数据一致性怎么说
7. 怎么测试，测试有哪些思路
8. 策略模式取消订单，对于这个功能你会怎么测试
9. Redis的数据结构你知道多少，分别对应哪些场景可以使用
10. MySQL的事务特性
11. MySQL并发事务问题，隔离级别
12. 做一道算法题—股票的最佳购买时间
13. 写一个SQL—给定订单表（用户id、订单id、产品id，产品对应金额，购买时间），查询在今天每个用户购买每个产品的金额

题目8

自我介绍

1.用过哪些有关并发编程以及JUC的组件

2.用过线程池吗

3.ThreadLocal的作用 项目中咋用的 不回收的后果

4.mysql索引数据结构

5.b+树叶子节点存的什么

6.回表查询

7.用过的redis数据结构

8.zset底层数据结构 除了排行榜其他的使用场景

9.项目中乐观锁的应用与实现

10.rabbitmq的消息分发

11.项目中如何用的rabbitmq

12.微服务拆分的优点

13.模板模式的用法与好处 项目中如何用的

14.用docker部署的步骤

二面

你们用dubbo是吧？你知道netty吧？

接口幂等

kafka和RocketMQ的区别？

分布式链路追踪的原理：

Mybatis的原理、如何和mysq交互的？

count(*)和count(字段)的区别、效率

linux信号是什么：我举例kill命令

kill命令具体是干什么的

讲解一下这个题目：

用户在搜索框的时候搜索，会有提示词条，如何实现：我说前缀树等

反正就一直讨论这个搜索问题

题目2

mq如何防止丢失

mq如何防止重复消费

消费端如何保证消息不重复消费

redis实现分布式锁需要注意哪些？

redis 会删除错锁吗？

注解是如何实现的，原理

反射原理？在什么阶段？

lombok注解的实现原理？什么机制？在什么时候运行的？

java 数值上下界的越界，你怎么理解？long类型的上界赋值给int类型，会怎么样？

你怎么理解幂等？

你开发了一个接口，如何保证幂等

数据库的一条数据，多个线程并发修改，用canal如何保证写到es是对的呢？

加密，签名，摘要分别是什么？使用场景？摘要用的私钥还是公钥验签？

题目3

自我介绍
介绍一下最近的项目，做了什么？解决的问题，如何解决的，
大模型的上下文长度是有限的，如何解决的
大型项目还是会有很多的上下文，这种情况怎么解决
可不可以分步骤做？一步一步压缩上下文，
MCP了解多少
MCP server，client有没有开发过
AI还了解多少？还参与过什么ai项目
文本相似度怎么计算的？
POI搜索是如何实现的，可不可以使用大模型来优化一下
可不可以通过意图识别，找相关数据，在数据层面做好
计算机网络了解吗？websocket底层是怎么做的
广播和单播分别指什么
设计一个生产者消费者模型，生产者生产不同类型的消息，消费者消费自己订阅的类型的消息

快手

一面

题目1

消息队列如何实现功能解耦和压力分散？

延迟队列是如何处理未完成任务的？

整个流程的QPS或容量预估是多少？是否有进行性能测试？

缓存与数据库的一致性如何保证（同步策略、定时任务间隔等）

JVM垃圾回收 简述JVM的垃圾回收机制（分代回收、可达性分析）？

有哪些垃圾回收算法（标记清除、标记整理等）？

不同垃圾回收器（如CMS、G1）的特点和区别？

多线程与锁 synchronized和volatile的区别？

ReentrantLock的公平锁与非公平锁实现原理？

CAS机制在锁中的应用？

集合框架 HashMap和ConcurrentHashMap的区别？

ConcurrentHashMap的分段锁机制（JDK 1.8前后变化）？

MySQL MySQL索引的底层数据结构（B+树 vs B树）？为什么选择B+树？

默认的事务隔离级别是什么？如何解决幻读问题（间隙锁）？

Redis Redis为什么比数据库快（内存操作、IO多路复用）？

Redis高可用方案（集群、哨兵模式）？

数据分片（Sharding）如何实现？节点间如何通信？

操作系统/网络

HTTP请求处理流程 从客户端发起HTTP请求到服务端响应的完整过程（DNS解析、TCP连接、报文拆解等）？

服务端架构中如何接收和处理请求（Web容器、业务逻辑分层）？

消息队列

RabbitMQ vs Kafka 为什么选择RabbitMQ而不是Kafka？两者在高并发场景下的差异？

题目2

1、Kafka，raft一致性协议，选举过程；

2、慢sql优化方式；

3、mysql的bufferpoll；

4、优化器按照什么指标决定走不走索引；

5、你怎么去解决深分页，其实这个感觉无法避免回表的，只是回表数据大小的问题(回id肯定比回整行数据拷贝开销低)，业务性避免吧；

题目3

1. 介绍仿大众点评项目的主要模块。

2. 项目难点。

3. 用户登录模块中，Redis 缓存是同步过程还是异步过程，同步过程会有什么问题，用户量大时发得慢该怎么办。

4. 若用消息队列存储验证码相关信息，消息队列的架构是什么，出现消息堆积该怎么办。

5. 增加消费者数量能否随意增加，有什么其他考虑。

6. 双重拦截器的作用，是否能在一个拦截器中实现相关逻辑，双重拦截器有什么好处。

7. 优惠券秒杀中，扣减的是数据库还是 Redis 中的数据，扣减后使用分布式锁和写入消息队列的顺序是怎样的。

8. 若写入数据库时发生异常，Redis 中已扣减的数据是否需要恢复，如何恢复，恢复操作是否会对线上产生影响。

9. 为什么在优惠券秒杀中使用 Lua 脚本，不能用 Redis 的其他数据类型（如 increment 或 decrement 计数器）的原因。

10. 预检信息包含哪些操作，能否在外部完成。

11. 若不在 Lua 脚本中实现预检资格、查询是否一人一单和扣减库存等操作，而在代码中实现，会有什么问题。

12. 一人一单的限制能否保证，若快速点击或用脚本点击两次，是否会突破限制。

13. 一人一单的限制应该在哪个环节实现。

14. 写入消息队列之前应该完成哪些操作。

15. 讲解 JVM 的相关知识，包括类加载器、运行时数据区、执行引擎等。

16. 垃圾回收算法在年轻代或老年代是如何应用的，年轻代的结构是怎样的。

17. 对 AI 有哪些了解，如何使用大模型。

题目4

Java的锁介绍一下

aqs原理

有哪些锁用到了aqs

cms和g1垃圾回收器有什么区别

有进行过jvm调参嘛？为什么要进行这样的调参

介绍一下spring boot的启动过程（完全不知道啊）

tcp粘包说一下，如何解决？

tcp4次挥手

数据处理

有100亿个url，怎么找到相同的url

题目5

1、kafka和rabbitmq 相比有哪些优缺点
2、kafka的延迟情况和数据丢失情况 应该怎么查看
3、redis的hash数据结构是什么样的？那么使用String和使用Hash的区别是什么呢？他们各自的优缺点是什么呢？
4、redis的缓存穿透、击穿、雪崩是什么问题，如何解决？
5、redis 缓存一致性，如何在大量数据的情况下做一致性处理？
6、CompletableFuture的底层原理（还是有点不太熟悉）
7、CompletableFuture内存泄漏的问题（这一块 又吃了没看源码的亏）
8、ThreadLocal的内存泄漏的问题
9、mysql的持久性是如何实现的
10、mysql中undolog redolog中的区别有哪些
11、常见的OOM情况，如何解决（这里说的是读取大量Excel数据的情况）

题目6

JAVA

1、反射的原理，应用场景，哪些场景不能使用反射？自定义一个注解需要定义哪些方面的信息

2、线程的生命周期，各个状态之间的转变通过哪些语句？保证线程安全的方式及优缺点？ThreadLocal会导致什么问题？

3、JAVA中的锁有几种方式？同步锁原理及申请流程、可重入锁原理及申请流程

4、MYSQL事务的隔离级别，分别会导致什么问题？如何在MYSQL中查询隔离级别

5、MYSQL主从同步机制

6、Redis持久化机制、AOF文件重写、Redis宕机重启后，什么机制保证其快速恢复？

SPRING

1、IOC、AOP、bean的实例化流程。IOC中如何解决循环依赖

1、使用过什么消息队列？怎么确保一个消息发送成功？

2、介绍实习项目的背景、技术架构、负责的内容。使用了哪些中间件？

3、怎么使用分布式锁？怎么设置锁的key，拿锁成功和拿锁失败对于下游业务的影响，怎么保证幂等性

4、怎么设置限流参数，阈值等？

5、在项目中做了什么优化手段，最终拿到了什么结果？

题目7

mysql索引结构，b+树查询的时间复杂度，建立索引的原则？
什么是AOP？什么是动态代理？
什么是注解？注解是怎么起作用的？
什么是反射？什么时候会用到反射？
java的内存模型是什么样的？栈是用来干什么的？
什么是设计模式？你了解哪些？
实现单例模式的时候有什么需要注意的？为什么要做双重校验？什么时候会用到单例模式？

题目8

1、自我介绍

2、项目一拷打（10min）

3、Java中线程池任务提交的流程是怎样的？

4、线程池的拒绝策略有哪些？

5、提交到任务队列的任务，它的消费策略是怎样的？

6、如果是无界队列，还需要非核心线程吗？

7、无界队列存在什么问题？一般在什么场景下使用无界队列？

8、谈谈 Java 里面锁消除和锁升级

9、synchronized 可重入吗？能保证可见性吗？

10、某个服务 CPU 利用率到 100% 了，如何排查？

11、如果是 OOM 了怎么排查？

12、自己有用过 jmap 和一些工具去排查过错误吗？

13、MySQL 有几种事务隔离级别？从低到高说

14、什么是幻读？

15、MySQL 是怎么去解决幻读问题的？

16、谈谈 Kafka

17、为什么项目中技术选型用的是 RabbitMQ？

18、RabbitMQ 的数据持久化是怎么做的？

19、线程和进程的区别？

20、线程的安全怎么保证？

21、进程通信的方式有哪些？

22、进程间通信，它的数据传输大概是怎样的流程？怎么能让数据从一个进程传递到另一个进程去？

23、Redis 常用的数据结构有哪些？

24、谈谈 ZSet 的具体实现？为什么数据规模大的时候采用跳表而不是压缩列表？

25、查一个有序集合里面元素的个数，复杂度是多少？命令是什么？

26、取有序集合某个元素的分数，命令是什么？复杂度是多少？

题目9

\1. ThreadLocal的原理和存在的问题
\2. ThreadLocal在Spring当中的应用
\3. ThreadLocalMap和HashMap的区别（hash方法不同，设计原因角度出发）
\4. 线程池的使用，核心参数设计
\5. 如何根据业务需求动态修改线程池参数
\6. 动态线程池实现原理
\7. 对比Zookeeper和Redis实现分布式锁的优劣（CP vs AP、是否引入新组件）。
\8. 阐述设计一个Redis分布式锁需要考虑的关键问题（死锁、锁超时、释放锁的原子性、owner验证）。
\9. 追问如何评估Redis锁的超时时间（看门狗机制、压测）。
\10. 阐述一次慢SQL优化的完整过程：从发现问题（Oncall告警）到定位（Explain分析），再到解决（调整where条件利用联合索引的最左前缀原则）。

题目10

线程池？线程池的生命周期？什么时候转换？

jdk8版本及以后哪些新特性你用过？什么帮助？

对反射的理解？反射的缺点？什么时候用什么时候不用？

注解，结合经历说？

说说一些框架中的注解？

Spring如何扫描到注解的？详细说说流程？

bean的实例化流程？

Spring如何解决循环依赖？详细说说

介绍一下线程的状态和流转？

线程池核心参数和执行流程？

实现一个简单的线程池需要注意什么？

mysql的数据库隔离级别？解决的问题？

用什么语句可以尽快测出隔离级别？

mysql的主从同步？

主从同步有哪些模式，如何确认是否完毕？

常用的数据库版本mysql用的什么方式？

设置了索引但没生效，原因？

题目11

1、自我介绍

2、项目一拷打（10min）

3、Java中线程池任务提交的流程是怎样的？

4、线程池的拒绝策略有哪些？

5、提交到任务队列的任务，它的消费策略是怎样的？

6、如果是无界队列，还需要非核心线程吗？

7、无界队列存在什么问题？一般在什么场景下使用无界队列？

8、谈谈 Java 里面锁消除和锁升级

9、synchronized 可重入吗？能保证可见性吗？

10、某个服务 CPU 利用率到 100% 了，如何排查？

11、如果是 OOM 了怎么排查？

12、自己有用过 jmap 和一些工具去排查过错误吗？

13、MySQL 有几种事务隔离级别？从低到高说

14、什么是幻读？

15、MySQL 是怎么去解决幻读问题的？

16、谈谈 Kafka

17、为什么项目中技术选型用的是 RabbitMQ？

18、RabbitMQ 的数据持久化是怎么做的？

19、线程和进程的区别？

20、线程的安全怎么保证？

21、进程通信的方式有哪些？

22、进程间通信，它的数据传输大概是怎样的流程？怎么能让数据从一个进程传递到另一个进程去？

23、Redis 常用的数据结构有哪些？

24、谈谈 ZSet 的具体实现？为什么数据规模大的时候采用跳表而不是压缩列表？

25、查一个有序集合里面元素的个数，复杂度是多少？命令是什么？

26、取有序集合某个元素的分数，命令是什么？复杂度是多少？

题目12

1.自我介绍

2.挑最熟悉的项目讲，讲一些技术选型，对比redis实现的消息队列和kafka有什么区别

3.redis list底层数据结构

4.redisson怎么实现

5.redis实现分布式锁用什么命令

6.Java有哪些锁

7.reentrrantlock实现原理，为什么用CAS

8.reentrrantlock用了什么设计模式?

9.项目中的AI聊天为什么用websocket，不用HTTP？

10.进程和线程什么区别？

11.进程调度算法有什么？

12.虚拟内存的好处？

13.页表置换算法有哪些？

14.页表置换算法具体举例

题目13

. 你在实习的时候主要做了什么，介绍一下
\2. 实习经历拷打，问题延伸，非常深入，难绷…实习生几个月怎么可能把几年的代码库全部掌握…
\3. 拷打起手：
\1. 唉，我问一下哈..
\2. 比如说：…
\3. 然后开始拷打延伸
\4. 提出一些假设的case，如何解决？
\5. 你实习的时候主要做了什么，介绍一下
\6. C端请求的整体链路、QPS、RT、量级
\7. 锁到底是主线程抢占的，还是子线程进行抢占的？
\8. CompletableFuture在执行过程中，如果线程池的等待队列满了，你该怎么处理？
\9. 各个拒绝策略的适用场景是什么？
\10. 有些拒绝策略会丢请求，如果说不需要丢请求，并且对要丢的任务进行记录，怎么处理？
\11. AOP你用来写什么的？
\12. 讲一下@Transaction的底层实现，参数一般怎么用呢？事务传递属性了解吗？

题目14

1.用过哪些锁，sync和Reentrantlock区别
2.怎么查看索引是否生效，有两个字段，id，name，一个id主键索引，一个id，name联合索引，select * 过滤条件为 name 走什么索引（这个自己纯sb😭，后来想想自己当时答的一坨屎）
3.我有很多方法需要有及其相似的前置操作，该怎么做（aop）
4.mybatis工作原理（这个压根没准备😭）

题目15

\1. 你觉得项目一的难点或亮点在哪？

\2. 为啥用 ES 不用 MySQL？有啥区别？

\3. 数据库和 ES 各自是怎么存数据的？

\4. 数据库怎么优化？

\5. 讲讲分库分表，水平和垂直分别怎么分？会有什么问题？

\6. 你说一个节点 16KB，那怎么算 B+ 树的高度？

\7. 二级索引一定会回表吗？索引在什么情况下会失效？

\8. 缓存雪崩、穿透、击穿有啥区别？

\9. 怎么保证缓存和数据的一致性？了解延迟双删吗？

\10. JVM 内存模型是怎样的？1.8 前后方法区有啥区别？存些啥？除了元空间还有哪些区？

\11. 了解 G1 吗？Survivor 区有几个？为啥是两个？

\12. 如果 CPU 和内存占用率都很低，但频繁 Young GC，怎么排查原因？

\13. 线程池有哪些参数？拒绝策略有哪些？

\14. 手撕：连续子数组最大乘积和最大和，两者有啥不同？你怎么理解？

\15. 有什么想问我的吗？

题目16

1.Java中有哪些线程安全的集合？

2.如果我的代码中现在使用的是hashmap，hashmap中有一个数据，需要怎么做才能在线程安全的情况下对这个数据进行操作？

3.现在维护一个ConcurrentHashMap，map中有一些数据，现在有两个线程对这个数据进行读操作，是否有线程安全问题？

4.如果将ConcurrentHashMap换成hashmap， 同时两个线程去读这个数据会有安全问题吗？

5.线程的创建方式都有什么？

6.线程池的核心参数都有哪些？

7.一个核心线程数是5，最大线程数是10，阻塞队列是100，拒绝策略是拒绝丢弃，线程创建的时候有几个线程？

8.在线程池创建完成之后，线程池提交了6个任务，线程池有几个线程？

9.JVM 运行时数据区都有哪些？

10.JVM里面的对象的生命周期的介绍?

11.实现 “多线程查询数据且最大并发数不超过 5” 的需求，怎么设计代码？

12.要做一个压力测试，期望是100个线程，100个行为同时发生，怎么去设计这个压测代码？用到什么技术？怎么做？

13.JVM 中有哪些垃圾回收器？

14.你的项目怎么解决传统bi的问题？

15.对于一些大文件，是怎么上传的？

题目17

\1. 常见的 GC 算法有哪些？
\2. 什么情况会出现 Full GC？
\3. 业务层面上，Full GC 可能的原因是什么？
\4. 如何定义线程安全？
\5. 一般通过什么手段保证线程安全？
\6. 如何理解可见性？
\7. 什么情况会出现死锁？
\8. 怎么解决死锁问题？
\9. 对于 MySQL 来说，如何检测死锁？检测完后怎么避免一直死锁？
\10. 你在 MySQL 数据使用过程中，是否发现过死锁？是什么场景？或者解决过死锁吗？
\11. MySQL 有哪几种锁类型？
\12. 同一个 SQL 语句对同样一份数据，加的锁类型会完全一样吗？
\13. Java 中为什么需要 ReentrantLock？
\14. 设计线程池时，需要考虑哪些因素？
\15. 一个线程池提交了一个父任务，父任务执行中提交多个子任务到同一个线程池，会有什么问题吗？
\16. 并发中的伪共享问题是什么？
\17. 什么情况会出现慢 SQL？
\18. 除了加索引，还有哪些解决慢 SQL 的方式？
\19. 为什么要小表驱动大表？
\20. 小表驱动大表和大表驱动小表在复杂度上有什么差异（假设小表数据量为 N，大表为 M）？
\21. 什么情况下需要分库分表？
\22. 分表是否足够？为什么要分库？
\23. 为什么 MySQL 同一个库存放过多数据时性能会变差？
\24. Redis 常用的数据结构有哪些？
\25. Zset 主要做了什么？它主要使用的是什么数据结构？
\26. 如何处理 Redis 大 key 和热 key 的问题？你是否遇到过这类问题？
\27. 你在实习时，做过最有挑战的事情是什么？或者有过一开始觉得很难，后来通过学习等手段解决的经历吗？

二面

题目1

1. 介绍仿大众点评项目的详细内容，包括学到的东西、难点、重点。

2. 详细描述一次C端用户登录行为在系统背后的完整数据链路，每一步系统要做什么、存储在什么地方。

3. 验证码存储在Redis中的key是什么。

4. 用户再次登录时，前端是否做防刷或重复登录验证，还是依赖短信验证码。

5. 验证码发送在系统后台的操作流程。

6. 用户登录态如何维持。

7. 为什么要返回TOKEN，能否返回手机号。

8. TOKEN在浏览器端存储在什么地方。

9. 将TOKEN存到authorization字段的原因。

10. authorization是header还是body字段。

11. 双重拦截器拦截的内容，以及从什么地方取TOKEN。

12. 从Redis中取TOKEN的key是什么。

13. ThreadLocal中存储的是什么。

14. ThreadLocal的定义是什么。

15. ThreadLocal的生命周期是什么。

16. 用户发起HTTP请求时线程是创建还是复用。

17. 在post handler中remove ThreadLocal的原因。

18. 已登录用户后续操作是否需要更新ThreadLocal。

19. 拦截器拦截的请求类型及作用。

20. 分布式系统中，用户请求路由到不同机器时是否需要重新登录。

21. ThreadLocal存在的必要性，能否用其他东西替代。

22. ThreadLocal的优点是什么。

23. ThreadLocal设置的生命周期或服务的生命周期是什么。

24. postHandler的调用时机。

25. 声明线程的方法有哪些。

26. 线程池的核心参数及各自作用。

27. 等待队列是否越长越好。

28. MySQL事务的隔离级别及各自举例。

29. Redis的数据结构及各自特性和适用场景。

30. 最近在学习的内容及大模型相关学习情况。

三面

题目1

索引构建有什么用，底层是怎么做的

httpclient 如何设置连接池，设置参数后 httpclient 底层是怎么做的，用了什么数据结构

为什么操作系统需要虚拟内存，一个 32 位系统里有物理内存 2G，对应的虚拟内存应该有多大？为什么一共就 2G 物理内存，通过虚拟内存技术之后，可以给应用程序提供 4G 内存，多出来的 2G 哪里来的，

假设要写一个网络爬虫，这个爬虫里面有一个功能，想快速的判断一个 URL 地址它之前有没有被爬过。用什么样的数据结构会比较合适？

拼多多

一面

题目1

一、Java基础与JVM（6题）

HashMap扩容时链表转红黑树的阈值为什么是8？退化为6的原因？

synchronized锁升级过程？

G1垃圾回收器如何预测停顿时间？Region大小如何设置？

volatile能否保证数组元素的可见性？如何解决？

ThreadLocal内存泄漏的根本原因？JDK改进方案？

Java 8中Stream的并行处理原理？ForkJoinPool工作窃取机制？

二、并发编程（5题）

AQS中为什么用CLH队列而不用普通链表？

线程池核心参数设置规则？美团动态调整方案？

ConcurrentHashMap的size()方法为何不精确？替代方案？

如何用CAS实现一个无锁栈？ABA问题如何规避？

CompletableFuture如何实现多个异步任务依赖执行？

三、数据库与Redis

MySQL索引失效的10种场景？最左前缀原则的底层原理？

十亿级订单表如何优化分页查询？

Redis大Key删除导致集群崩溃，如何避免？

Redis事务与MySQL事务的ACID区别？

缓存与数据库一致性方案对比？拼多多秒杀采用哪种？

Redis Cluster的slot迁移过程会阻塞请求吗？

MySQL死锁排查步骤？如何用gap锁解决幻读？

四、分布式与微服务（6题）

TCC事务的Confirm阶段失败怎么办？

如何设计一个支撑百万QPS的分布式ID生成器？

Nacos如何实现配置动态推送？长轮询原理？

RocketMQ如何保证消息不丢失？

Dubbo的泛化调用使用场景？如何实现服务降级？

CAP理论在拼多多购物车中的取舍？

五、系统设计（4题）

设计拼多多砍价系统，如何防止刷单？

订单超时未支付自动关闭，如何实现？

如何设计一个实时热卖排行榜？

分布式锁在库存扣减中的应用，Redisson实现原理？

题目2

\1. 自我介绍
\2. 实习亮点
\3. Java线程池类型，应用场景
\4. 线程池怎么进行线程回收的
\5. 为什么要用线程池
\6. 说说RPC是什么
\7. 设计RPC框架有哪些要点
\8. 常用的序列化方式
\9. 为什么要进行序列化
\10. 写题：二叉树后序遍历（非递归）
\11. List list = new ArrayList<>()发生了哪些内存分配
\12. 操作系统是怎么进行递归的
\13. 为什么要有多态
\14. 多态父类表现出子类的行为，运行时是如何实现的呢
\15. Java泛型是怎么实现的
\16. Java为什么要用泛型擦除，为什么不像c++一样
\17. sout( "Hello World!”) 运行过程。字符串是怎么打印到屏幕上的
\18. 为什么要有内核态
\19. 从操作系统层面分析java -jar xxx.jar 是怎么运行的，在操作系统层面的可执行文件是什么
\20. Java和JVM的关系
\21. Java和Python有什么区别（答了JIT）
\22. 算法：找到一个具有最大和的连续子数组
\23. 介绍一下AOP
\24. 怎么指定AOP生效的地方
\25. Java中注解是怎么生效的
\26. 谁去扫描注解的
\27. 介绍一下IOC
\28. 介绍一下MQ
\29. MQ有什么特性

三面

题目1

\1. 自我介绍
\2. 你们的RPC框架用的是什么，了解底层实现吗
\3. 线程池的参数、底层的运行原理
\4. 设计一个无锁的工作队列
\5. 有了解服务的GC
\6. G1和ZGC
\7. 如何防止一个服务过载（答了监控、限流、熔断）
\8. 知道堆外内存吗，什么时候会用到堆外内存
\9. c++了解吗
\10. 二叉树的后序遍历-非递归

京东

一面

题目1

1.项目介绍

2.spingboot做了什么事情

3.sql怎么优化，mysql怎么优化

4.bean注入有哪些方式

5.auto wire注解的原理，spring怎么做到加载有这个注解的对象

6.mybatis能不能直接new一个dao 接口的对象，怎么做？拦截器功能原理，使用场景

7.接口性能问题怎么看，怎么分析哪个阶段有问题

8.mysql的三种日志介绍一下

9.发生宕机redolog和binlog怎么协调作用的

10.宕机后怎么恢复数据，一条数据怎么确定回滚还是恢复

11.生产问题定位，平时怎么做的

12.线程池执行过程

13.g1回收器跟cms 相比，各自适合什么场景

14.使用的什么检验的框架，原理是什么

15.mysql索引为什么快

题目2

做项目遇到的问题和解决方法

有没有用到多线程的东西，ThreadLocal

线程池参数怎么设置的

如何保证线程安全

synchronized 和 ReentrantLock 区别

Java 并发类有哪些

ConcurrentHashMap原理

redis 常用数据结构及底层实现

zset 跳表

缓存击穿、穿透、雪崩

击穿、穿透区别在哪

题目3

1、自我介绍+实习项目

2、Spring AOP原理是什么，Java的反射和代理有哪几种

3、BeanFactory和FactoryBean的区别是什么

4、ES的倒排索引是如何实现的

5、除了简历上的项目，还有其他项目可以介绍一下吗？

6、Mysql的间隙锁是什么

7、了解哈希索引吗？为什么innoDB不采用哈希索引

8、了解哈希冲突吗？ 处理哈希冲突的方法有哪些？

9、 为什么HashMap 不采用ThreadLocalMap解决哈希冲突的方法（开放寻址法）

10、如果要想实现可以按put的顺序遍历HashMap，要怎么实现呢？那如果要想改变其中的顺序呢？

11、 java的可重入锁是如何实现的？

12、 如果想实现可重入的分布式锁要如何实现呢？

13、对于树的三种遍历方式，分别有什么用途？

14、了解JVM的内存模型，大概介绍一下？

15、实例对象都是在堆上分配吗？（我提到了可以在栈上分配）

16、那有哪些对象是可以直接在栈上分配呢？—

题目4

1、自我介绍

2、电脑上有没有生产环境

3、项目的难点和解决思路以及你的收获

4、ES的原理（这个没有很理解问的意思

5、分布式锁、redisson的实现

6、Redis数据结构

7、JUC的syn和可重入锁

8、JVM+GC

9、MySQL的使用场景，MySQL的使用经验，

10、聚集索引和非聚集索引

11、B+树

12、事务ACID和隔离级别

13、乐观锁、悲观锁

14、为什么有spring，springboot的优势，用了spring全家桶的哪些

15、spring的AOP、spring其他的设计模式

题目5

查一张学生表，表里有学生名字，如何查出学生名字中哪些是重复的？
缓存的过期策略有哪些？
后端一直更新数据，前端一直查缓存，在更新的间隙，缓存是空的，导致缓存穿透，怎么解决？
有没有别的思路可以解？比如通过全局的乐观锁？
创建多线程会用哪些方法创建？
了解completable future 吗？

题目6

1. 面试官介绍了下岗位
2. 自我介绍
3. 现在实习的地方，有留用机会吗？
4. 拷打项目一（10分钟）
5. 本科不是计算机，怎么跨考上的？当时怎么准备的？
6. 考研学专业课时，碰到过什么困难吗？怎么解决的？
7. 用户登录为啥用 Spring Session 来管状态？它内部是怎么跑的？
8. 密码用 MD5+盐值 来校验，有啥风险吗？
9. 现在让你重新设计密码加密存储，你会怎么做？
10. 数据万象服务是干嘛的？项目里怎么用的？
11. 如果要实现图片搜索，比如搜“小狗”，就能找出所有带小狗的图片，你会怎么设计？
12. 什么场景下需要用多级缓存？
13. 怎么保证多级缓存和数据库的一致性？项目里是怎么做的？
14. 用 WebSocket 做多人协作编辑，假如有 100 个人同时改一张图，怎么设计才能避免操作互相覆盖？
15. 你提到加锁，具体怎么加？用 Redis 还是别的？锁什么？锁的粒度多大？
16. 加锁会让其他用户干等着，没法操作，这块怎么优化？
17. 平时除了项目，还学了啥新技术吗？
18. 你觉得用什么锁来控制虚拟线程比较好？
19. 最近一年用过哪些 AI 编程工具？
20. 看你一直在一个地方生活学习，以后想去哪工作？

题目7

. 实习期间学到了什么，结合项目介绍一下
\2. mysql和redis的一致性如何做
\3. 如果不订阅binlog，还能保证一致性吗？
\4. 什么场景会出现数据库和缓存不一致
\5. zset的底层是怎样的
\6. 跳表为什么快
\7. redis原生的锁是用什么命令，流程是怎样的，如何释放锁，里面参数都是什么
\8. 什么时候会出现当前线程的锁被其他线程解锁？ （不会）
\9. redis持久化
\10. 需要实现百万qps的系统，功能是实时排行榜，查询量很大，实时更新，可以理解为微博排行榜，怎么实现？
\11. DDD架构讲解一下
\12. kafka的topic和partition的关系
\13. partition越多越好吗
\14. 想实现顺序的消费，生产者发出来的消息是顺序的，一个partition，多个消费者，怎么实现？
\15. kafka怎么保证消息不丢失？
\16. 如何解决java浮点数丢失的问题
\17. 多线程的场景题：主线程执行到一半的是要开始10个子线程，子线程执行完之后主线程在执行，怎么实现
\18. completableFuture的实现原理
\19. countdownlatch的原理
\20. 自己实现一个线程安全的计数器，怎么实现？
\21. 场景题：电商大促，负责秒杀，通过线程池实现，怎么设置核心参数
\22. 实现功能：写个sql，给一张订单表，至少有订单id，userId，createTime，筛选出昨天下单的用户是近一年第一次下单的用户，怎么实现
\23. 索引相关，联合索引A，B，C，where a > ? and b = ? c != ?，怎么走

题目8

1.Future和CompletableFuture区别，Future有回调吗，除了forkjoin线程池，还知道什么线程池？项目里用的什么线程池，线程池流程
2.零拷贝底层原理，select/poll/epoll各自优化点，各阶段是否阻塞
3.kafka底层咋样，和rocketMQ区别，为啥rocketMQ不用零拷贝（沉默了十秒），消息队列日志，broker啥的
4.redis单线程体现在哪，有什么优势
5.介绍了一下cola4架构，防腐层
6.在实习公司用过dubbo吧？服务发现、负载均衡怎么实现的，函数式调用咋连接的？（我只知道架构长啥样，不懂原理啊
7.实习参与了一个月的业务迭代，能独立完成需求评审-开发-上线了吧？我不知道啊)
8.应用发布时，监控哪些指标
9.挑一个业务迭代讲讲
10.联合索引失效的场景

题目9

\1. 部门是干什么的？
\2. 介绍实习的一个项目
\3. 介绍一下自己的项目
\4. 说说lua脚本是怎么保证原子性的？
\5. 为什么Redis这么快
\6. redis主从节点如何同步
\7. 客户端与服务端有connect函数，如果IP写错和端口号写错，二者在程序反应上有什么区别？为什么？
\8. 了解僵尸进程吗？
\9. 了解管道的机制吗？
\10. 执行管道命令之后操作系统内部会做哪些处理？
\11. 为什么TCP连接要三次，但是断开要四次？

题目10

\1. AIO、BIO、NIO 分别是啥？有啥区别？

\2. 抽象类和普通类有啥区别？

\3. 讲讲 HashMap 的扩容机制，还有 ConcurrentHashMap 的原理和线程安全是怎么保证的？

\4. 线程池的核心参数有哪些？设置时要考虑什么？

\5. 注解的实现原理是啥？

\6. 一个类调用自己内部类上的注解，这个注解会生效吗？

\7. 介绍几种常见的设计模式？

\8. 常见的垃圾回收器有哪些？各自有什么特点？

\9. 遇到高并发页面访问，有哪些解决方案？

虾皮

一面

题目1

1. 讲一下xxl-job的架构与实现原理(实习有xxljob)

2. xxl-job怎么保证每一个实例的任务只调用一次

3. 算法题:用栈实现队列，说思路

思路:用两个栈，判断第一个栈是否为空，为空将第一个栈的所有元素转移到第二个栈，否则弹出最上层的元素

1. 算法题:一篇文章找出使用频率最高的k个单词

思路:使用一个HashMap存储每个单词出现的频率，转换成结构体，然后再建堆，再堆排序

1. topk拓展:建堆的时间复杂度是多少？

2. topk拓展:堆排序的时间复杂度是多少?

3. topk拓展:你这样不会有点慢嘛，还有更优解嘛？

4. 数组和链表在数据结构上的区别是什么？

5. 数组和链表的使用场景有什么区别？

6. 了解哪些MySQL存储引擎

7. InnoDB引擎有什么特性

8. 索引是数据结构是什么，有什么特点？

9. MySQL有哪些锁

10. MySQL的事务四大特性是什么

11. MySQL的隔离级别是有哪些

12. MySQL默认隔离级别是？

13. RR和RC的区别是什么？

14. 可重复读什么时候能解决幻读，什么时候不能？

15. TCP协议怎么保证可靠性？ 三次握手四次挥手、流量控制、拥塞控制

16. 讲讲流量控制怎么做的

17. 拥塞控制算法有哪些？

18. TCP粘包是什么

19. 怎么解决TCP粘包？

20. 如果我的TCP里面就有换行符该怎么解决

21. 进程之间的通信机制有哪些

22. 进程、线程、协程之间的区别

23. 线程有独立的内存空间嘛？

24. Redis有哪些数据结构

25. ZSet的底层实现是什么数据结构

26. 跳表的实现原理是什么？

27. 跳表插入一条数据的具体实现是什么

题目2

1. java的内存模型

2. 数据库优化，sql优化

3. 消息队列有什么作用，kafka在项目中有什么作用

4. 2个topic， 一个group消费者组，一个topic 异常rebalance， 另一个会受影响吗？

5. 讲一下mysql的redo log、binlog、undo log，

6. mysql崩溃以后恢复流程？mysql崩溃之后未提交的事务怎么办？

7. B+数主键索引和非主键区别

8. inplace DDL(不会)

9. RPC框架中，怎么做链路追踪

10. 网页中输入网址的流程变化

11. tcp与udp区别

12. go 的协程和java的线程区别

13. go多协程和java多线程 同时读写，共享资源 处理 方式一样吗

14. java 的线程与内核线程， go的协程与线程的 映射方式一样吗？（1:1，n:m）

题目3

1.可以讲讲用户从发送请求url之后会发生什么吗 ✘

介绍了一下SpringMVC的流程，从url到DispatcherServlet再到各个处理器部件等

实际上面试官是想问从网络通信层面上它们发生了什么

回复不太清楚，只介绍了一下域名通过DNS解析成IP然后请求到后端服务器

2.了解cookie和session吗 ✘

答的很不好，因为自己只学了JWT和token完全没想到会问这块，只答出前者存储在客户端后者存储在服务端

3.了解MySQL中的事务隔离级别吗，它们分别解决哪些问题，具体讲 ✔

4.学过哪些排序算法？✔

冒泡，二分，快排

5.MySQL中索引的数据结构？讲讲优势和为什么✔

6.Redis常见架构✔

7.了解正排索引和倒排索引吗✘

答不太清楚只知道es库中通过倒排索引建表实现较高的搜索效率

8.手撕，反转链表✔

9.延迟队列是什么，了解底层实现吗✘

回答了xdelayed延迟队列的基本应用场景和概念，底层实现不知道

10.AMQP中消息可靠性原理✔

11.你项目中的推荐功能是怎么实现的

简单讲了一下调用了分词器和向量模型的API将库中视频基于标题分到我给出的聚类中

题目4

1. 自我介绍
2. 你常用哪个 JDK 版本？
3. 选一个你熟悉的项目，说说它配了什么垃圾回收器？
4. 描述一下 CMS 的回收流程及每个阶段的作用。
5. CMS 有哪些阶段会 Stop-The-World？
6. 新生代和老年代的划分机制是什么？
7. 对象从新生代晋升到老年代的条件有哪些？
8. 说说 AOP 的最基本实现方式。
9. Spring AOP 生成代理的两种场景/方式分别是什么？
10. 你在项目里用过微服务吗？用的什么技术栈？
11. 有做过哪些 MySQL 调优？举一个具体例子。
12. 当时如何定位到这条慢 SQL？用了哪些工具或命令？
13. 解释 Explain 结果中哪些字段说明索引未生效。
14. Redis 持久化有哪些可选策略？
15. RDB 与 AOF 各自有哪些刷盘/触发方式？
16. 如果要求“不丢数据”或“高性能”分别怎样配置？
17. TCP 四次挥手中 TIME_WAIT 状态的含义是什么？
18. 为什么需要等待 2MSL 才能进入 CLOSED？
19. 你在项目里用过 CompletableFuture 吗？
20. 它与 Future / Task 组合相比有什么优势？
21. 如果异步链路里包含数据库事务，事务回滚会不会有问题？为什么？
22. 线上 Linux 服务器常用命令熟悉吗？
23. 如何在文件里查找关键字？
24. 如何查找某个文件？

题目5

上来先写两句SQL

给了一个学生表

1.两个字段不重复，重复的话就无法插入，建立合适的索引

2.获取表中录取学生人数第二多的公司，要求公司录取学生的人数至少大于3

表设计的一些考量、索引建立的一些考量

sql优化在工作中遇到的一些实例。

一道题：

尽快实现亿级别数据的求和。

八股：

redis为什么快？

Java的一些设计原则

题目6

消息队列如何实现功能解耦和压力分散？

延迟队列是如何处理未完成任务的？

整个流程的QPS或容量预估是多少？是否有进行性能测试？

缓存与数据库的一致性如何保证（同步策略、定时任务间隔等）

​

JVM垃圾回收 简述JVM的垃圾回收机制（分代回收、可达性分析）？

有哪些垃圾回收算法（标记清除、标记整理等）？

不同垃圾回收器（如CMS、G1）的特点和区别？

多线程与锁 synchronized和volatile的区别？

ReentrantLock的公平锁与非公平锁实现原理？

CAS机制在锁中的应用？

集合框架 HashMap和ConcurrentHashMap的区别？

ConcurrentHashMap的分段锁机制（JDK 1.8前后变化）？

​

MySQL MySQL索引的底层数据结构（B+树 vs B树）？为什么选择B+树？

默认的事务隔离级别是什么？如何解决幻读问题（间隙锁）？

Redis Redis为什么比数据库快（内存操作、IO多路复用）？

Redis高可用方案（集群、哨兵模式）？

数据分片（Sharding）如何实现？节点间如何通信？

操作系统/网络

HTTP请求处理流程 从客户端发起HTTP请求到服务端响应的完整过程（DNS解析、TCP连接、报文拆解等）？

服务端架构中如何接收和处理请求（Web容器、业务逻辑分层）？

消息队列

RabbitMQ vs Kafka 为什么选择RabbitMQ而不是Kafka？两者在高并发场景下的差异？

题目7

​ \1. 从浏览器输入URL到返回内容的完整过程
\2. 用大模型服务器的网络通信关键点是什么（猜想想问的是输出的流式stream是怎么体现的，怎么实现的服务端主动推送，长链接。）
\3. ThreadLocal是什么？如何避免并发安全问题？
\4. ThreadLocal如何避免内存泄漏？（jdk设置的自救机制，finally块中主动释放）
\5. 接口响应慢如何排查？ 系统层面考虑 cpu和内存层面考虑
\6. 联合索引的存储结构是怎样的？
\7. 索引的优缺点？
\8. 数据量大时如何分库分表？ （如何考虑什么时候分表，什么时候分库）
\9. 如何安全地删除Redis中的大Key（一个几千万数据的List）？
\10. 10亿无重复数据，如何快速、随机、等分成10份？
\11. 一个文件从磁盘读出，通过网络发出，内存经过几次拷贝？（考察零拷贝之类的）
\12. CPU执行代码的整个过程是怎么样？

题目8

1.innodb 和 myisam
2.tcp四次挥手，time_wait之后要等多久，为什么
3.https 加密过程
4.zset底层实现，redis用过哪些数据结构
5.bitmap用过吗
6.hyperlog用过吗
7.linux查看连接的命令
8.redis持久化，rdb和aof区别？
9.mysql主从同步怎么做
10.binlog重放是并行的还是串行的？会出现什么问题
11.主从同步什么情况下会丢数据
12.redis的事务？和mysql事务的区别

题目9

1.自我介绍

2.介绍实习项目，引申一些八股和场景题

3.jvm内存结构，栈里面放什么东西？

4.new一个对象具体做了哪些事？

5.垃圾回收器cms过程是怎么样的？

6.垃圾回收算法有哪些？

7.g1回收器怎么建立可预测的停顿时间模型？

8.Mysql 锁有哪些？MVCC如何实现？日志有哪些？

9.B+树的结构？和b树的区别？索引的原理？

10.联合索引a,b,c，判断sql有无走索引

11.redolog具体怎么保证持久化的？

12.了解哪些设计模式？

13.简单工厂和工厂模式的区别

14.单例模式分为哪些？

题目10

1.自我介绍
2.问了下哪段实习对你提升最大，技术等等的提升、实习的业务和简历上写的限流
3.springboot比较好的一个方面是它有注解的一个方式去管理一些实例，这种思路解决了什么问题（面试官提示说循环依赖，没听说过!)
4.Java里面是怎么解决的？就垃圾回收那块（可能面试官想问Java垃圾回收是怎么解决循环依赖的，我理解成问垃圾回收器了
5.java的注册发现用什么？可以定制一些算法吗？
6.怎么发现服务的？比如服务有两台，那请求是第一台还是第二台
7.中间应该还问了些问题，忘记了

题目11

\1. 实习经历
1.1 队列选型的依据是什么
1.2 下游异常除了告警还能怎么做
\2. 快速排序的时间复杂度和空间复杂度
\3. 网络IO模型有哪些
\4. select和epoll的区别
\5. epoll水平触发和边缘触发的区别
\6. 分布式锁的实现方式
\7. mysql实现分布式锁怎么解决锁占用不释放
\8. 缓存三剑客
\9. 公司年会入场券抽票，有些人有多张票或者票的权重不一样，要怎么设计
\10. 安全问题有了解哪些

题目12

1.点评秒杀流程，秒杀过程中用户退单怎么加回去(没考虑过，瞎说，另外中途一直打断让他说又不说，有点红）
2.实习
3.mysql隔离级别，实现原理，mvcc
4.索引，聚集索引，非聚集索引，索引覆盖，回表
5.创建索引上来直接用b＋树吗
6.联合索引我直接多加几个字段是不是一步到位，和少量字段有啥区别
7.redis主从同步
8.最新的垃圾回收算法是什么，怎么解决碎片化

题目13

\1. AOP 底层原理是啥？

\2. SQL 性能问题一般怎么解决？

\3. 简单讲讲数据库的底层原理？

\4. redo log、undo log 和 binlog 有啥区别？

\5. 详细说说支付渠道对接和数据表结构优化的工作？

\6. 怎么用策略模式让支付渠道更容易扩展？还有，怎么用线程池做 RPC 调用？

\7. 实现异步线程池时，碰到过啥技术难点或亮点吗？

\8. 测试效率提升 70%，这数怎么来的？

\9. Excel 是怎么自动收集搜索结果来提升测试效率的？

\10. 用了哪些自动化测试工具？

\11. 详细讲讲 Java 的垃圾回收？

\12. HashMap 的原理和扩容机制熟吗？

\13. 聊聊 Redis 的缓存淘汰策略？

\14. 除了 Linux、MySQL、Python、Java，还用过 Kafka、Redis 这些吗？

\15. 核心代码模式算法题：求一个字符串的最长回文子串。

题目14

1.自我介绍
2.实习
技术架构
业务；安全方向考量 （消费失败
RocketMQ？
Kafka顺序性要求
延时队列；那你有了解过市面上的延迟队列吗（没#牛客AI配图神器#
Redis你用过什么数据结构

技术架构
聊天消息怎么存储的
有了解过市面上的同类产品吗（没
同时登陆
每次都判断token吗
日志组件怎么做的

9亿个IP地址去重 （想成9G个字符串了，，
做成白名单服务如何做 （分表
MySQL太暴力了，你能自己实现吗；内存中实现

题目15

1.自我介绍

2.zset底层数据结构，跳表怎么设置的层高，了解压缩列表吗

3.布隆过滤器原理，你具体怎么配置的，它如果发生删除会怎么样？

4.bitmap了解么，怎么实现的签到功能，还有个压缩位图了解吗

5.mvcc原理解释（必须非常细！！！甚至模拟事务让我判断应该是哪个版本）

6.可重复读的readview和读已提交，读未提交的区别

面试官追问我这快10min

7.间隙锁介绍及作用，有唯一索引的时候间隙锁会锁哪几条记录？

8.redis的数据库连接出现问题，你在客户端，怎么排查解决

9.linux查网络情况，查找文件

10.为什么用jwt，jwt好在哪，你还知道哪些鉴权方式

11.全局唯一id怎么生成的，你了解雪花算法吗，哪些组成，为什么保证唯一

12.https加密握手流程

13.tcp拥塞控制算法

题目16

\1. 项目成果是什么？怎么做的质量保障？
\2. 什么场景用到ES？Redis都扛不住ES能抗住吗？方案合理吗？
\3. 有用过本地缓存吗？
\4. 算法：
Result confirmOrder(Order order) (}伪代码实现下单接口(扣减库存、创建订单)，要求:
吞吐高
商品不超卖
每人限购一件
\5. 针对写的伪代码的问题：下单怎么保证同步？
\6. 并发场景下同一个用户两个请求过来，会不会超卖？前一个请求的异步订单还没有保存，这时第二个请求也没有检测到已经下单，可能出现并发问题，怎么解决？（创建一个轻量的任务去DB，再去做其他的更新）
\7. 算法：
给定数字数组，返回第三大的不重复的数，不存在返回null
要求:遍历和比较次数尽可能少(时间复杂度限制)，空间复杂度尽量低(空间复杂度限制)
7767856->6
7767766->nul
6 7 -> null
\8. 间隙锁是干啥的？
\9. 意向锁的作用呢？是表锁还是行锁？解决什么问题的？
\10. select a, b, c from t where a = xx and b = xx orderby c desc a,b有联合索引，c也有索引 这个场景走的什么索引？c怎么扫描？怎么优化？
\11. select a, b, c from t where a = xx and b = xxa.b有联合索引 怎么优化？为什么？
\12. 秒杀场景中怎么保护系统的稳定性？系统外部的？
\13. 有什么限流算法？漏铜令牌桶？
\14. 怎么设置限流的值？怎么去确定这个值？需要关注哪些指标？
\15. 应对Redis热点问题有什么解决办法？
\16. Redis和数据库一致性怎么做保障？非秒杀环境
\17. binlog丢失用什么方法去兜底？
\18. 怎么解决Redis数据没有及时更新，检查出现的数据不一致情况？（从DB入手，加一个保证线程去查看）

题目17

1.redis缓存穿透，击穿，雪崩问题
2.怎么解决Redisson实现秒杀场景的“一人一单”，避免超卖
3.如果让你不用redission实现，你会怎么做，讲讲代码
4.判断什么是热点数据（指标，数据结构）
5.为什么会有定时任务重复执行的问题，这是一个什么场景
6.zet底层逻辑，讲的详细一点（就是说一下跳表的数据结构，为什么选择跳表+哈希）
7.跳表底层存储的单元逻辑（没太听懂，问了ai说是​从内存结构​​、​​编码方式​​到​​元素存储的二进制布局讲）
8.自己实现一个锁，你会怎么样去实现
9.持久化机制，你会选择什么样子的
10.redis的过期机制
11.redis集群的部署，整体讲一下（数据分片、高可用和自动故障转移等机制）
12.主从节点，主从节点崩溃怎么处理，删除节点，增加节点，主节点故障
13.java进程中一个线程om了，这个程序会怎么样
14.如果是栈溢出呢，怎么解决
15.jvm空间分配介绍（着重讲堆内存）
16.垃圾回收机制，堆内存空间分布，为什么要这么分，一个程序怎么切换到其他内存
17.GC策略
18.数据库底层数据结构（对比讲解）（为什么选择）
19.红黑树怎么实现的，特点
20.查询数据库整个过程（楼主既讲sql执行过程，也讲了整个网络的过程）
21.数据库查询中的重复度问题及解决方案​
22.数据库隔离机制，acid都是什么，数据库事务的理解，并发问题，隔离级别的实现
23.数据库mvcc讲解一下
24.分布式事务策略（不会）
25.讲一下计算机网络模型
26.http和socket的区别
27.四次挥手过程，产生两个wait都在哪里，怎么解决
编程题目:
电商系统，实现一个商品库存的接口，提供
increaseStock(int amount)
decreaseStock(int amount)

解决并发的问题，可以使用乐观锁(txt手打，从零开始，使用cas去解决，然后还要写测试并发的代码)

二面

题目1

1. 自我介绍

2. 优惠券平台项目是怎么做的

3. 牛券项目拷打:秒杀是怎么做的？

4. 秒杀接口如果Redis都扛不住了怎么办 限流

5. 怎么限流？ Sentinel或者使用Redis

6. 讲讲这两种限流是怎么实现的

7. Sentinel限流是全局维度还是单机的

8. Sentinel限流的原理是什么

9. 优惠券平台优惠券分发过程是怎么样的

10. 实习中主要做了哪些工作

11. 实习中遇到哪些技术难点

12. 实习还有什么收获

13. 讲讲对MySQL分库分表的理解 讲了为啥要分表、为啥要分库、垂直分和水平分等等

14. 垂直分表主要是解决什么问题？为什么要进行垂直分表

15. 为什么一张表有好几个字段要垂直分表呢，除了业务上的解耦？

16. 水平分表主要是解决什么问题？为啥要进行水平分表

17. 水平分表有哪些方式

18. 哈希法和范围法的优劣

19. 如果对优惠券表进行分库分表，用户要查询自己的订单，怎么办

题目2

定量的分析我的项目系统的极限处理能力（没弄过，根本不会）。我说没弄过不知道，又问现在就是要分析它的承受能力，你应该怎么做（还是不会…）

3.项目组件选型考量，用了哪些东西为什么要用这些（最后焦点放在消息队列的选型上，问rocketmq和kafka相较RocketMQ有什么优点，这些优点底层怎么实现的）

4.Redis缓存穿透（缓存空对象+布隆过滤器，还有没有优化手段（不知道…））

5.Redis持久化（设计一套兼顾AOF完整和RDB快的持久化方案）

6.Java垃圾回收机制

题目3

. 做个自我介绍吧。

\2. 实习时碰到的最大挑战是啥？

\3. 问题解决后，有深挖过根本原因吗？

\4. 后来有做什么来防止问题再发生吗？

\5. 方案设计上，还有哪些能改进的地方？

\6. 要是重来一次，你会怎么做？

\7. 除了 Shopee，还在面别的公司吗？

\8. 你想做测试、工具开发还是业务测试？偏技术还是偏业务？

字节

一面

题目1

1. redis相关

3.1 redis有什么数据结构

3.2 GEO的原理

3.3 排行榜用什么数据结构

3.4 朋友圈共同好友用什么数据结构

3.5 实现数字的原子+1用什么方式

1. mysql相关

4.1 mysql有哪些锁

4.2 分布式锁还有哪些实现方案

4.3 很多多余的索引有什么缺点

4.4 怎么利用索引做查询优化

4.5 大表统计多少条数据行满足筛选条件怎么优化

4.6 亿级数据大表怎么做查询优化

4.7 分表要怎么做

4.8 分区表有听说过吗

1. ThreadLocal是什么，内存泄漏是怎么回事

2. 并发访问资源怎么防止冲突

3. 场景题：一个守护进程负责对工作进程重启，但是现在工作进程一直没拉起来，怎么去定位问题

题目2

进程间的通信方式

http属于哪一层分层模型：应用层

访问网页的全过程

丢包、粘包问题

创建子进程的方法：fork

PgSQL和MySQL的区别，选型时的考虑

建立索引选择字段的原则，最左匹配原则的底层原理是什么

数据库范式

Zset的底层原理，查询和增删改的时间复杂度

题目3

• 预计能实习多久？
• 能简单介绍一下实习期间做了什么吗？
• 能介绍一下什么是 Websocket 吗？
• Websocket 和 SOCKET 有什么区别？
• Websocket 怎么保证连接是保活的？
• 你了解大模型的一些相关的技术概念吗？
• 实习项目中除了聊过的内容，还有什么比较有技术深度或挑战性的事吗？
• 刚才提到的选择算法（雪花算法）有哪些潜在的问题？
• 雪花算法的时钟回拨问题怎么解决？
• 能介绍一下项目解决什么问题，或者主要有哪些产品功能吗？
• 秒杀模块遇到的核心问题是什么？
• 用 Redis 扣减库存时，怎么保证 Redis 和 MySQL 数据一致性？
• Redis 库存数量是什么时候初始化的？
• 一道字节的算法题：小于n的最大数（网上能搜到原题）
• 先讲思路再写代码，面试官对思路里面有问题的地方会做一些提示
• Redis 是单线程的，单线程会引入什么问题吗？
• MySQL 的 Innodb 存储引擎默认的事务隔离级别是什么？
• Innodb 的默认事务隔离级别能解决幻读问题吗？
• 你还在面试其他的实习吗？
• 有拿到 offer 吗？
• 如果通过面试，你最早什么时候能来实习？

题目4

1. 麻烦你先简单自我介绍一下。

2. 这个搜索优化里边你做了什么工作？有什么结果？

3. 机票场景我理解可能有很多这种目的地、价格这种不同的因素，尤其是价格非常敏感，那这个缓存会缓存价格吗？

4. 那如果你的9天拉到30天，会不会缓存命中率的确提高了，会不会造成后续到下单环节实际库存不匹配？

5. 影响多大？

6. 我们扩展一下，假如说你的最终下单环节没有这个下单环节在，实际查询服务商的价格给你兜底了，你的缓存需要精准，怎么做？

7. 你刚提到这个主动缓存，这个“主动”怎么理解？

8. 你能描述一下一个简单的搜索系统主要包含哪些环节吗？

9. 就比如说召回、快速分析、召回、精排这些。

10. 你刚提到多个供应商的同一个航班线的这种合并会比较耗时，为什么它耗时？

11. merge为什么耗时？

12. 那就必须得等最慢的规则才能返回吗？

13. 那进一步的能不能回来一个就处理一个？

14. 耗时和CPU哪个更重要？

15. 你们线上CPU利用率是多少？

16. 这个 MCP 项目的难点在哪？

17. 动态工具加载和自动注册在 MyBatis-Plus 里底层是怎么实现 MCP 服务动态注册和热更新的？

18. 你这边主要熟悉的开发语言是什么？

19. synchronized 的底层原理是什么？

20. synchronized 是可重入的吗？

21. 什么叫可重入？

22. 它是怎么实现可重入的？

23. 关于线程池：核心线程数10，最大线程数20，任务队列容量100，不断提交任务时，线程和队列状态会怎样变化？

24. Redis 里 zset 是怎么实现的？

25. 压缩列表和跳表什么时候用压缩列表，什么时候用跳表？

26. 跳表的结构是怎么样的？

27. MySQL 查询：成绩表中分数在80到90之间，排名前五的学生姓名及分数，SQL 怎么写？

28. 操作系统中线程和进程的区别？

29. 在 Linux 系统上，怎么查当前系统负载较高的进程及其实时负载？

30. 定位某个 Java 业务进程 CPU 很高，该怎么进一步定位问题？

31. 大模型里“温度”参数的作用是什么？

32. MCP 和 Function Call 有什么区别？

33. SSE 和流式 HTTP 有什么区别？

34. SSE 断开了怎么办？

题目5

1. Http请求中有哪些请求方式？

2. 说一下Https是如何保证链接安全的？

3. Https的加密方式是怎样的？对称还是非对称？

4. Http的状态码都有哪些，代表什么意思？

5. TCP是如何实现可靠传输的呢？

6. 在浏览器中输入url后会发生哪些事情？

7. C++指针和引用的差别是什么？

8. 说一下动态链接和静态链接是什么，以及各自的优缺点

9. 说一下深拷贝和浅拷贝的区别

10. 进程通信的解耦机制？

11. linux进程通信的几种方式以及各自的应用场景

12. 说一下数据库的范式

13. 说一下多线程死锁的原因吧

14. 如何避免死锁呢？

15. java是如何保证线程安全的呢？

16. 说一下java里面的容器是如何保证线程安全的？

17. AOP在Spring中是怎么实现的呢？

18. 说一下缓存穿透、击穿、雪崩

19. 写的项目有没有上线过，有没有用户大规模使用，缓存穿透这些问题是怎么遇到的？(答：模拟这些问题)

20. 你是怎么模拟这些过程的呢？

21. 你的linux主要是用来干嘛的呢？

题目6

1.实习 拷打 主要db

2.分表的设计

3.MQ的使用

4.索引 联合索引

5.缓存三剑客

6.缓存一致性

7.分布式锁

8.浏览器输入域名到响应返回

题目7

缓存里存什么数据？
Redis 的什么特性使它可以胜任缓存工作？
Redis单线程是什么意思，为什么单线程就会快？
IO多路复用是什么？单线程和多线程在IO多路复用里的区别？
在实习过程中，用的HTTP版本是多少？
HTTP2.0和3.0相比1.1的优化方式？

题目8

1.实习项目，问了20分钟左右
2.你多线程是怎么用的
3.线程进程区别，怎么创建线程
4.线程池原理，拒绝策略
5.数据库索引数据结构、优点，你们部门项目是怎么加索引的
6.springboot用到了什么设计模式
7.spring的循环依赖
8.项目里用过什么注解
9.数据库事务的隔离级别和原理
树的z型遍历，但是是英文题

题目9

实习中有什么挑战性的东西
有用到什么中间件吗
八股/场景
一条sql语句的执行顺序（内部流程，解析器执行器）
一条sql语句的执行计划（计划，先联表还是先分组）
innodb事务隔离级别
MySQL索引结构
为什么选择B＋树
什么时候会索引失效？
说一下联合索引
对(a,b,c)这样的索引，where b > 10 and a = 1可以利用索引吗
业务中发现数据库机器CPU和内存都很高怎么办
怎么处理慢查询
redis常见数据类型
redis为什么适合缓存
redis cluster的读写 分片等

题目10

1.自我介绍
2.项目拷打(20min)
a. 介绍一下视频上传功能
b.介绍一下私聊功能
3.手撕K个一组反转链表(最后不够K个也要反转没注意)[15min]
4.介绍一下MVCC？
5.介绍一下间隙锁？

题目11

1. 详细介绍一下你那个海洋物联网平台都干了些啥？

2. 那么多不同设备的数据，是怎么接到系统里的？它们的数据结构有啥不一样？

3. 刚提到了反射，Java 里有几种方式能实现反射？

4. CGLIB 和 JDK 动态代理，主要区别是啥？

5. 数据是怎么存的？如果按半年存，要查 6 月到 8 月的数据该怎么做？

6. 怎么监控和优化慢 SQL？

7. 索引在什么情况下会失效？MySQL 有哪些索引类型？聚簇索引和非聚簇索引有啥区别？

8. Spring 的事务传播行为有哪几种？它们有啥用？

9. 消息队列在项目里一般都用在哪些地方？

10. 聊聊你对 Kafka 的理解？它的核心组件和 broker 都是干嘛的？怎么保证消息不丢？

后45分钟进入编程环节:

核心代码模式算法题”求前缀和”

附加问题:

1. 用 Shell 写个脚本，统计日志里出现次数 Top 10 的 IP。
2. 用 Java 实现同样的功能（要求自己手写堆）。
3. 给你一些日志（每条包含 ip、start、end），算一下一天中同时在线人数的峰值是多少。

题目12

\1. 自我介绍
\2. 讲一个实习或项目的亮点
\2. go协程和c协程区别？栈溢出会崩溃吗？
\3. read系统调用会发生几次用户态到内核态的切换？零拷贝会发生几次？
\4. 浏览器输入url，客户端发包过程？，在数据链路层用到什么协议，是怎么路由到目标服务器的？
\5. mysql的mvcc版本链存在什么位置？
\6. mysql日志没落盘突然断电了怎么办？
\7. 两阶段提交涉及哪些日志？

题目13

自我介绍
详细介绍第一个项目 （我的项目放的比较多）
面试官了解项目的基本情况（使用场景和一些简单的细节）
数据量级比较大的时候如何解决（详细答了解决的算法设计思路，这块项目里详细做过）
关于项目中网络传输和数据存储的一些问题
数据传输中用到的协议
介绍另一个项目（做了个web服务框架）
安全认证的方式
链表和数组的区别
一个场景题，数组取数据相关的
线程和进程的区别
详细说明适用场景
多线程的CPU底层处理方式
介绍一下设计模式的一些情况

题目14

1.自我介绍
2.实习
微服务，怎么交互
http是一种序列化协议吗 （答错了，更高级一些）
RPC
socket
Kafka写内存可以吗
3.项目 （项目做的太简单了
表的设计
聊天有历史记录吗
为什么压测

redis
缓存一致性

题目15

# 你觉得go和Java有什么区别，这俩本质上语言这方面有没有什么区别

​

# 讲一下 Java的反射原理和机制是什么，怎么获取具体实现，反射的话说是不是它里面所有的属性都可以获取到，私有属性可以吗

​

# 对象创建的哪个阶段去调用的，编译值还是运行值，你说一下反射的优点和缺点都是什么，它的性能怎么样？它运行的时候是怎么获取的

​

# Java里边常用的数据结构有哪些?也就是集合数据结构,集合 list和数组的区别,常见的list有哪些类型，我new一个ArrayList的时候是预分配内存还是插入的时候再分配内存

​

# 现在我们假设有一个数组也好，map也好，我们想保证一个数据操作它的读写是现场安全的，请问有几种办法,ReetrantLock实现原理是什么，锁的话说会有性能问题除此之外还有什么保证现场安全的办法

​

# 跑程序的容器里边，它有两个比较核心的指标对吧？这两个核心指标分别是什么，那么我们加锁的方式是用什么换什么

​

# 解释一下https的原理行吧，说一下https的原理实现方式以及加密方式，还有它是如何保证安全的，那个证书有没有可能被劫持

​

# Redis在哪些场景下用的多，或者说什么场景需要用到Redis，你用之前知道它大约能抗多少QPS，它为什么快

题目16

\1. 自我介绍
\2. 简单问了实习
\3. 事务的ACID特性是如何保证的，没有redolog的引擎怎么实现持久化
\4. mysql主从同步的过程
5.主从同步延迟长的原因
\6. 数据库和缓存如何保证一致性
7.项目拷打

题目17

pringBoot的IOC的基本原理和底层实现？
出现循环依赖怎么解决？有没有遇到过三级缓存也解决不了的循环依赖
OOM是什么，什么情况会出现OOM？
如果出现了栈溢出的情况，程序会直接终止吗？
进程和线程的区别？
Java线程有哪些状态？Java的线程和操作系统的线程是一一对应的吗？
数据库在什么情况下会出现索引失效？为什么左模糊查询会导致索引失效？
数据库的第一第二第三范式都是什么？
RPC是个什么样的概念？有哪些常见的RPC框架？RPC是怎么实现的？

题目18

1.问实习二十五分钟 后开始基础知识拷打

2.讲讲Java的锁 synchroniz

3.说说锁升级的过程

4.为什么会有这个过程 主要是避免什么

5.reentranlock 和synchronize 的区别 生产上一般用哪个

6.AQS的实现原理

7.有哪些实现类 以及怎么实现的

8.类加载机制

9.双亲委派是什么

10.索引失效是由什么导致的

11.慢sql排查优化

12.联合索引 最左前缀匹配原则

13.redolog binlog如何写入磁盘 两阶段提交

14.如果没有两阶段提交会怎么样

15.MySQL 的原子性是怎么保证的

16.数据更新日志的写入顺序

17.redis的网络模型是怎么样的 （为什么这么快）

18.什么是分布式 以及会带来什么问题

19.分布式数据一致性怎么保证

20.消息队列的推拉模式了解么

21.如何保证消息幂等

22.如何保证消息不丢失

23.kafka为什么那么快

24.零拷贝是什么 讲一下流程 减少哪些地方的拷贝 是完全没有拷贝么

25.一个消息队列的好坏有哪些评价指标 有什么作用

26.rocketmq和kafak的区别

27.设计模式 应用场景

题目19

SpringBoot 是怎么加载 Bean 的？

反射为啥会影响性能？

线程安全的工作原理是啥？

线程安全里，主内存和工作内存分别指啥？

进程和线程有啥联系和区别？

HashMap 和 TreeMap 有啥区别？

红黑树查询效率为啥高？

红黑树是怎么实现自平衡的？

网络编程里，你知道哪些 IO 模型？

BIO、NIO、AIO 里的 N 指的是啥？

TCP 是怎么保证可靠传输的？

题目20

\1. redis数据结构
\2. zset底层实现，底层为什么用跳表，跳表底层实现，跟其他数据结构比有什么好处
\3. redis持久化方案，实现方案，优缺点
\4. io多路复用
\5. 又问了select，epoll，poll实现区别优缺点，这些实在不会了，操作系统没仔细看
\6. 哈希冲突处理方法 ，缺点？其他处理哈希冲突方法？
\7. tcp与udp分别介绍一下，区别？
\8. redolog undolog binlog
\9. mysql隔离级别
\10. 覆盖索引，索引下推
\11. mysql数据从入库到提交到修改有哪些流程
\12. 怎么用redis实现分布式锁
\13. 怎么增加标识
\14. 实现分布式锁其他方案？
\15. 用过哪些mq介绍一下
\16. 数据库表设计，结合他们的一些业务写一些建表语句（应该是用来水时间的）

题目21

\1. 讲一讲美团做的项目
\2. 项目最终拿到什么收益？
\3. 有用过mysql、redis、kafufa等吗？
\4. mysql四个事务隔离级别和每个级别锁对应的问题
\5. 死锁怎么产生的？怎么解决？
\6. mysql常见的分库分表一般怎么做？
\7. 举一个分表的场景，垂直？水平？
\8. 如果是有一个账单表怎么分表？按userId？有没有可能某个用户数据量巨大？怎么解决？（按照时间戳）
\9. 涉及分布式锁的时候需要注意哪些问题？
\10. redis分布式锁如果单节点挂了，应该怎么解决？
\11. redis说是二进制安全，为什么？SDS相比普通的String优势在哪？redis的String底层类型是什么？
\12. redis有序集合底层是什么实现的？
\13. 跳表的数据存储和读取是什么步骤？
\14. ES为什么适合做模糊查询？
\15. ES最适合做什么场景？如果分表过多要联合查询怎么做？
\16. 设计一个秒杀系统要做什么考虑？
\17. 库存扣减怎么保证不超卖？
\18. redis中作库存扣减怎么做？会出现并发问题吗？

题目22

1.实习内容拷打（甚至涉及到问我业务后续迭代可以从什么方面考虑）

2.分布式系统的了解

3.给一个几百万的数组，没办法一个机器放进去，怎么用分布式系统排序。

4.怎么避免按值分配后大部分值不会落在同一个区间内？

5.虚拟内存和物理内存

6.如何映射的

7.如果找不到映射会怎么样？

8.有哪些页面置换算法

9.Lru的数据结构

10.操作系统怎么提高流畅度

题目23

\1. 一些项目问题这里就不阐述了
\2. java重载重写有啥区别
\3. java中哈希表的工作原理是什么
\4. java中jvm的内存结构和java中对象创建过程是啥样的
\5. 垃圾回收与待计假说的原理
\6. MySQL中索引原理是啥
\7. MySQL中遇到慢查询如何去排查
\8. 简述快排时间空间复杂度
\9. TCP三握手、四握手的过程
\10. https协议中ssl的交换过程

题目24

\1. java里控制线程同步的方式

\2. java里有哪些实现锁的机制

\3. synchronized标记两个方法，我现在创建这个类的实例对象，我再创建两个线程，其中一个线程调用第一个方法的时候，第二个线程能否调用第二个方法。

\4. 线程池的常用参数，以及线程池提交任务的运行机制

\5. MySQL的InnoDB引擎有哪几种事务隔离级别？

\6. 可重复读相比读已提交解决了哪些问题？

\7. 举一下可重复读的一个具体场景。

\8. 最左前缀匹配。

题目25

1，问问专业背景，学过什么课，发现没系统学过计网和操作系统
2，情景题，如何设计一个旅游景点的门票，涉及到几张表，每个表之间的关系是什么样的，如何设置库存，控制人流量
1，计网，只知道一点，问了TCP和UDP
2，Java开发的单例模式？不知道
3，MySQL索引结构？B＋树，索引失效？不知道。事务，四大特性，如何实现这四大特性？
4，Redis有哪些数据结构，Zset的底层实现？不知道
5，手撕，数组中最小k个数。力扣面试题17.14。要求：不允许用java自带函数和方法，要给出时间复杂度和空间复杂度，且要尽可能小。

题目26

\1. 自我介绍一下。

\2. 能实习多久？

\3. Spring 和 Spring Boot 有啥区别？

\4. 聊聊内存，虚拟内存和物理内存是啥关系？

\5. 为什么需要虚拟内存？

\6. 堆和栈里都存些啥？

\7. HTTP、HTTPS、HTTP/2、HTTP/3 有什么区别？

\8. 网络协议的七层和四层模型是啥？为啥要有四层？

\9. IOC 和 AOP 的原理是啥？

\10. 进程和线程有啥区别？浏览器发请求这个过程是怎么样的？怎么避免线程冲突？

\11. 创建线程有几种方式？

\12. 锁有哪些类型？悲观锁和乐观锁有啥区别？

\13. 什么是装箱和拆箱？

\14. 短链系统怎么设计和优化？

\15. 100 个人和 100 盏灯，一开始灯都关着。第 i 个人会去按所有 i 的倍数编号的灯的开关。最后有多少灯是亮着的？

题目27

项目难点啊，轻耦合表现在哪啊，java的哪些特性实现了轻耦合啊，模块与模块之间怎么实现的轻耦合啊……
spring依赖注入方案有哪些？
Setter和基于接口的方案有啥区别？你用哪个？为什么？
柔性事务相对刚性事务有什么区别？中间状态不一致为什么保持了强一致？
tcp半包粘包？
tcp报文段有规定体积吗？头部有规定体积吗？
设计编码器是怎么解决半包粘包的？怎么判断这个包是不是属于这个包的开头部分……
tcp重复和丢包是怎么处理的？怎么保证收到的是完整的？（长度和内容）
udp实现IM的话应用层怎么保证安全和一致性呢？（重传部分问的很细（（

java集合的ArrayList和LinkedList有什么区别？内存部分有什么特点？应用场景有？
Hashmap底层怎么实现的？什么时候扩展到红黑树？有什么优势？红黑树怎么保证平衡？
场景题：
用户同时保存下载100本小说，有进度提示，希望下载的越快越好，也希望保障手机的性能，可以从哪些点入手来实现？
这样的item结构是啥样的？怎么更新下载状态？存到本地数据库要注意什么？为什么造成死锁？怎么解决？怎么设计锁？
网络层层面怎么进行优化？

题目28

. 实习经历、难点、亮点
\2. 数据库隔离级别+解决的问题
\3. 缓存穿透、击穿、雪崩+怎么解决
\4. HTTP、HTTPS的区别，加密的方式
\5. 介绍对称加密和非对称加密 + 两者的区别
\6. 具体讲解一下两种加密方式和一些加密算法
\7. 手机扫描电脑登录二维码实现登录功能，你怎么进行设计
\8. 服务端如何向PC客户端返回数据【WebSocket】
\9. 登录时向服务端发送请求使用什么协议？HTTP or HTTPS？
\10. 介绍一下WebSocket，HTTP 和 WebSocket的区别？

题目29

\1. Java 基础与数据结构

Java 面向对象有哪四个特性？

Java 常见数据类型有哪些？

HashMap 的底层实现是什么？为什么链表会转成红黑树？红黑树的时间复杂度是多少？

数组插入、链表插入的时间复杂度对比？

常见排序算法及时间复杂度（快排的原理和复杂度）。

Set 的底层结构是什么？和 HashMap 的区别？

线程安全的集合有哪些？

ConcurrentHashMap 的实现方式（Segment 锁、CAS 乐观锁）。

CAS 是什么？如果版本号不一致会怎样处理？

\2. 多线程与并发

Java 中的线程与操作系统中的线程是否相同？

多线程同步的手段有哪些？

GC 的作用是什么？常用垃圾回收算法有哪些？

Java 中默认使用的垃圾回收器及特点。

变量存在堆还是栈的条件？方法内局部变量存放位置。

\3. 网络与协议

你们项目是否是微服务架构？用的 RPC 还是 HTTP？

TCP 的可靠性如何保证？为什么挥手要比握手多一次？

如果不多一次会出现什么问题？

UDP 和 TCP 的区别，为什么游戏可以使用 UDP？

为什么需要 HTTP 协议？HTTP 和 TCP 的关系。

HTTP 长连接与短连接的区别和好处。

\4. 项目场景题

在支付项目中，如何保证交易的一致性？

什么是一致性（你们系统中指的是什么和什么一致）？

如何防止重复支付（尤其在数据未落库时的并发情况）？

分布式锁的实现方式（Redis setNX、过期时间、续租机制）。

Redis 除了做锁，还常用于哪些功能？

Redis 常见数据结构（string、list、set、zset 等）及底层实现。

为什么同一数据结构在数据量大小不同的情况下会使用不同的底层结构？

跳表的原理和时间复杂度，为什么还需要字典结构配合？

题目30

\1. 看你写到峰值qps有70w，那你观察过具体的资源数量吗

\2. map的使用场景，什么时候用hashmap什么时候用treemap

\3. arraylist 和 linkedlist的使用场景

\4. 既然想找到一个特定值都需要遍历，那为啥用arraylist不用linkedlist

\5. 网络层有哪些常用协议

\6. 说一说ip数据包传输过程中头部哪些字段会发生变化

a. 指引下说出了nat协议 私网ip转换公网ip 所以传播过程中ip地址其实会变化

b. TTL字段 → 牵扯到了tcp三次握手里面的MSL大小，刚好满足64次TTL过期才行

c. Identification，Flags ，Fragment Offset 当数据包大于了MTU进行数据粉骗的标识

(1). Identification 所有小分片都会和大分片保持一致

(2). Flag标识是否还有更多分片

(3). Fragment Offset标识了对应于原始分片的偏移位置

\7. nat协议具体的转换过程

\8. epoll的具体应用（不只局限于红黑树事件等原理，说说具体怎么用）

\9. 如何利用epoll实现一个心跳包检测

题目31

自我介绍
redis数据结构
set和sortedset有什么区别
点评的双重拦截器怎么实现的
线程和进程区别
计网七层模型每层的协议
http和https的区别
了解过其他语言吗
c++和Java你在学习过程中有什么区别

二面

题目1

• 跟电影售票有什么区别？剧院跟电影的区别是啥？为什么不能放在现有平台上呢？
• 项目有什么关键的设计？
• 如果我们要做一个登录态的保持，比如说七天免登录，那这个应该怎么做？
• access TOKEN 的过期时间是怎么保证的？
• 这个（TOKEN 过期时间）会被篡改吗？怎么做的非法校验？
• 为什么要两个 TOKEN 呢？
• 存在 cookie 里了，为什么没有暴露呢？（回答设置HTTP-only）设置这个是能做什么？（被拷打了，没有答明白两个token应该存放在哪）
• token控制 7 天有效期这个怎么控制？
• 那假设我们再把这个问题升级一下，就是如果 7 天内有登录，那这个 key 就不过期。那你怎么实现？
• 就是如果我连续登录，那理论上不是固定的过期时间，是超过多长时间不登录才过期？
• 只要你 7 天内有登录，那我们这个就不过期；如果超过 7 天没登录，那就过期重新登，那你应该怎么做？
• 那比如说我中间有登录，只要我中间打开 APP，这个就不过期，这个怎么做的？
• 会生成新的 TOKEN 刷新了，怎么刷？

题目2

1.自我介绍
2.为什么选用websocket
3.谁来敲定使用websocket的
4.websocket和sse区别
5.为什么sse原生只支持文本格式
6.sse是怎么做限制的
7.什么是双全工协议
8.使用websocket有什么要注意的地方
9.讲一下组件的原理 如何实现交互的
10.websocket能复用长连接吗
11.这个组件肯定是多机部署的 怎么知道你要选用的是哪个连接
12.你觉得这个组件设计的收益在哪里
13.假如让你实现一个websocket 如何实现
14.rocketmq和kafka区别
15.为什么kafka吞吐量大
16分布式锁的key和过期时间怎么设置的
17.为什么要用分布式锁 有别的方法吗
18.讲一下故障降级的机制

题目3

自我介绍
堆区栈区相关内容
静态变量
这些都问的比较深入
代码编译的过程
死锁相关
做的项目代码量
Nginx反向代理介绍一下
项目算法介绍
TCP流量控制的方法
具体介绍滑动窗口
http协议相关
设计模式

题目4

怎么设计保存用户登录状态、
HTTPS的握手原理
Binlog有几种格式
undolog的格式
事务失败回滚的具体执行过程
慢查询 怎么分析
redis的sds
redis的数据持久化方式
如何用redis去实现分布式锁
setNX命令详解

题目5

1、自我介绍（3min）

2、实习拷打（30min，其中有一个问题没回答好）

3、1000w的ur，10MB内存，如何排序

4、1个商品，1000w库存，20wQPS的购买，如何设计

5、括号匹配（easy，3min秒了）

题目6

\1. Java 中的接口和抽象类有什么区别？说几个使用场景。
\2. 手写一个 LRU 缓存，要求线程安全。
\3. 线程池的核心参数分别代表什么？最大线程数满了之后会发生什么？
\4. Spring 里的循环依赖是怎么解决的？单例、原型都适用吗？
\5. 如果多个线程同时竞争锁，JVM 是怎么决定谁先拿到锁的？
\6. 你了解过 volatile 吗？说说它和 synchronized 的区别。
\7. 数据库索引什么时候会失效？有哪些使用误区？
\8. HTTP 和 HTTPS 的底层加密原理能简单讲一下吗？
\9. 算法题：给一个数组和目标值，找出两个数，使它们的和等于目标值，要求时间复杂度尽可能低。
\10. Redis 是单线程的，那为什么它还这么快？
\11. 假设你有一张订单表，每秒几千条数据写入，怎么设计才能高并发插入同时还能支持实时查询？

三面

题目1

1.简单寒暄了几句

2.自我介绍

3.项目拷打

a.项目里Nginx负载均衡怎么做的？

b.Nginx配置集群怎么做？[以为问的是后端集群在Nginx怎么配置，结果是Nginx服务器集群怎么配置，没做过Nginx服务器集群根本不知道]

c.你的多后端服务配置在哪？[追问：为什么在Linux不在Docker上？]

d.从键入请求到你的服务返回响应中间发生了什么?

e.那你得到IP地址和MAC地址去请求集群中哪台Nginx服务器？

f.域名挂靠怎么挂靠的[没听懂这里想问什么，可能是请求的后端服务器的域名或者其他的，有牛友可以解答一下吗]

g.Linux命令了解吗？

h.我如果把Nginx的配置文件的所属目录更改了，那我要做哪些操作

这里面试官看出来我没什么实战经验了，直接问我你刚才说的是不是都是背的？（好想钻地缝里去）

开始拷打操作系统：

1.删除一个文件在操作系统里面是什么流程？

2.进程线程区别？

3.你刚才提到说进程独立分配资源，具体有哪些资源？

4.硬链接软链接了解吗？区别在哪？

接着拷打数据库：

1.做过数据库备份吗？对应SQL语句是什么？[忘光光]

2.来个SQL查询，分别找出学生表中姓李的男生女生个数（我的答案是group by 性别 having name like “李%”，面试官说为什么不where name like “李%” group by 性别，汗流浃背了）

3.来写一个反射的实例以及方法的调用（几百年没写过反射了，直接蒙了）

手撕在数组中出现次数超过一半的数字

面试官可能看我好多答不上来有点尴尬，接着问我消息队列：

1.kafka的原理？

2.kafka部署在几台机器上，一个分区几个副本？

题目2

自我介绍（面试官恭喜进入第三面 ┭┮﹏┭┮）
项目上介绍最能代表个人技术特点的项目
补充：项目这块因为是从0到1做的实现，本身项目做的很多，属于是项目业务型选手，所以面试官老师问的项目相关的内容
没有卡壳的基本，各种衍生优化场景当时做的时候也都基本有考虑到过，所以答得很顺畅，还跟面试官老师交流了一
些优化设计思路

然后就是基本的八股
面试官老师对网络通信和安全协议这块问的很多也比较细，绝大部分答得还可以

小红书

一面

题目1

1.介绍自己。讲一下项目

2.讲一下你用的这个reactor网络模型

3.你说把耗时操作push到线程池，那返回的结果是如何回到reactor的回调里的呢。我不会，胡扯了一通，还是对项目不够了解

4.讲一下epoll处理的过程

5.send返回以后数据是已经从机器发出去了吗

6.缓冲区满了以后阻塞模式的send会是什么表现？非阻塞模式呢

7.什么时候触发send缓冲区的清理。面试官提到tcp之后我说是ack以后

8.在reactor回调里不小心写了一个sleep会怎么样？影响的是一个连接还是一个线程？其实是想问线程切换相关

9.你提到nginx，有没有看过nginx的实现，我说没有，面试官说因为你之前提到用epoll实现reactor网络模型，其实应该先看一下nginx和redis的实现，因为他们就是标准的。而且redis还是跨平台的，不仅是epoll，会根据操作系统的不同选择不同的方案

10.你提到io_uring，是使用过吗？内核版本多少？是要解决什么问题？只是处理网络io还是包括文件？

11.你提到的这个用户态轻量级线程协程是什么？具体的切栈的逻辑你有看过吗？操作寄存器如果不用内联汇编的话你觉得c和c++可以实现吗？面试官意思是c/c++没有提供直接操作寄存器的接口

12.你这边还提到了使用过dpdk，dpdk和标准的内核网络栈有什么区别？是如何绕过内核的？驱动是用户态的还是内核态的？工作原理可以描述一下吗？它是主动去pull还是一个中断触发

13.read系统调用读本地文件一直到磁盘设备大概经历那些流程。我说我不太了解

题目2

实习里面这个监听binlog怎么保证一致性

mq有了解过吗

es有了解过吗

es和mysql的区别

mysql的索引结构

垃圾回收算法

jvm各区域

一次younggc的过程

synchronized锁底层

synchronized锁升级

mq有了解过吗（只说会kafka 讲了一下kafka的架构 以及一些机制

分布式一致性（说了raft，说了分布式事务

分布式事务实现的技术有了解过吗？这个不会

怎么看待ai

题目3

1. 自我介绍
2. 项目里面提到的一些内容
3. Redis使用场景、Redis数据结构、部署方式（单机/集群/哨兵）、Redis哨兵模式原理
4. MySQL与ES的核心差异、搜索索引优化内容、压测工具、项目核心难点
5. MQ使用场景、MQ原理（核心组成）
6. JVM运行时数据区域有哪些？
7. 常见垃圾回收算法及各自区别与优点
8. Java线程池核心参数
9. 线程池拒绝策略有哪些？
10. Java内置锁（synchronized）原理
11. 如何避免死锁？
12. 分布式一致性了解吗？分布式锁或分布式事务？

题目4

\1. 自我介绍
\2. 介绍一下第一个需求的背景
\3. 为什么使用CompletableFuture
\4. 线程池的参数以及你的设置
\5. 那如何设计一个阻塞队列呢
\6. 第二个需求的背景
\7. 插件是怎么实现的
\8. 什么是AOP
\9. Caffeine的内存淘汰策略，及其优势
\10. 第三个需求的背景
\11. 为什么选择使用工厂+策略进行优化
\12. 第四个需求的背景
\13. 有没有遇到什么问题

题目5

1、自我介绍

2、挑一个项目来介绍一下

3、Java 的 GC 过程会有 Stop the World，谈谈为什么要有 STW 的机制？

4、谈谈 Java 的SGC、G1、ZGC 垃圾回收器

5、G1 已经很不错了，为什么还要有 ZGC 这样的垃圾回收器，为了解决什么问题？

6、比如一个订机票的场景，涉及多个外部系统，首先要去看有没有票，然后第二个是支付要调支付宝或者微信去做付款，定完票可能过了半个小时才告诉我订票有没有成功。对于这种场景下的分布式事务，你认为怎么去处理和设计来保证一致性比较好？

7、基于消息传递的方案，消息可能传递失败，如何解决？

8、如果用消息队列，这种场景，怎么做技术选型？

9、做题：新兵报到，指导员命令所有人按身高大小，从低到高，依次站好，每次从头这边开始调整，但是要求，每次一次只能进行一次交换。输入 N(N <= 20)，输出 N 个士兵最终的排列结果。示例：N = 5，heights = [170, 167, 180, 175, 168]，输出：[167, 168, 170, 175, 180]

10、谈谈基于数据库的方式如何实现分布式锁？

11、谈谈基于 Redis 如何实现分布式锁？

12、为什么基于 Redis 实现分布式锁时，Set 命令要加 PX 参数？

13、基于数据库方式实现和基于 Redis 实现的区别？应用场景？

题目6

创建线程有几种方式？

聊聊线程池的设计和参数配置？拒绝策略和阻塞队列怎么选？

Spring AOP 的原理是啥？都用在哪些地方？

聊聊 Spring 的事务管理和隔离级别？

Redis 数据结构，随便挑一个讲讲底层原理？

项目里 Redis 具体用在哪了？

Redis 还有别的用法吗？它的分布式锁支持可重入吗？

怎么保证 Redis 和 MySQL 的数据一致性？

聊聊项目里防超卖的方案？为啥用库存扣减，而不是直接改库存数？数据库锁为啥没法完全解决超卖？

为啥要把行业映射配置放 Diamond 里？

阿里云 OpenSearch 全量和增量同步冲突了咋办？

实习时碰到过啥技术难题？

核心代码模式算法题：连续子数组的最大和。

电商的基础设施（比如库存、订单系统），你觉得有啥技术挑战？

题目7

1、自我介绍几分钟

2、实习的提效工具怎么工程化落地，混合了对Agent、MCP、RAG的工具性理解

3、Redis为什么高效

4、Redis的缓存雪崩、缓存击穿、缓存穿透及解决方案

5、TCP为什么是可靠传输

6、连不上服务（time_wait）怎么排查

7、多线程的锁机制

8、并发、并行及其应用场景

9、乐观锁和悲观锁

10、浅拷贝和深拷贝及其应用场景

11、假设有一个超大文件，以最省内存（并非空间复杂度）的方法输出前十个最大的数

12、有null值的两表联查

题目8

介绍实习业务
实习里面这个监听binlog怎么保证一致性
mq有了解过吗
es有了解过吗
es和mysql的区别
mysql的索引结构
垃圾回收算法
jvm各区域
一次younggc的过程
synchronized锁底层
synchronized锁升级
mq有了解过吗（只说会kafka 讲了一下kafka的架构 以及一些机制
分布式一致性（说了raft，说了分布式事务
分布式事务实现的技术有了解过吗？这个不会
怎么看待ai

题目9

八股文：
mysql执行一条update语句，全流程是怎么样的，假设存储引擎是innodb。（问了很久，包括加锁啥的面试官也引导着要求说一下，忘完了，这块说的不够详细）#牛客AI配图神器#

加一个联合索引后，在存储引擎内存储结构是怎么样的。就假如说加了（a,b）联合索引。

假如加了（a,b）联合索引，查询的时候还有个非索引字段c，最终查询流程是什么样的。

mysql redolog和undolog干啥的。

假如说mysql宕机了，redolog写入成功了，binlog还没写进去。mysql重启后会怎样。

redis String底层结构，为啥要这么设计

redis expire的工作原理

redis 除了基于内存以外，还有哪些点导致他性能这么高的。

你说io多路复用，为啥io多路复用性能高，说一下select poll，epoll原理。

redis分片集群，集群某个节点容量不够了怎么扩容。扩容后数据迁移怎么做。扩容后hash变化是怎样的。

go语言slice append流程

go语言垃圾回收机制，写屏障是为了解决什么问题的。

你对go转Java是什么看法，部门内主要还是Java

题目10

全程八股

TCP三次握手 四次挥手

TCP如何保证数据传输可靠性(滑动窗口

TCP UDP区别

http和websocket

http和https区别，是对称加密吗，为什么

类加载流程

双亲委派流程，如何打破

启动类加载器和扩展类加载器加载什么样的类

为什么要打破，有什么好处

垃圾回收算法，哪些算ROOT

如何触发full gc，cms和g1流程以及区别，三色标记

类什么时候回收，怎么回收

mysql三大范式，你设计一张表会从哪些角度考虑

mysql索引，聚簇，二级，哈希，联合，覆盖，前缀

mysql事务如何保证，acid如何实现

redolog和undolog在哪层，分别怎么实现

幻读是什么，如何解决

readview版本链读取规则

解释一下BIO，AIO，NIO，以及多路复用

详细说一下select，poll，epoll，如何做

线程池相关，如何预热，工作流程，如何手写拒绝策略

字节码如何增强

ThreadLocal为什么会导致内存泄露，反射原理，注解原理，用过吗，举个例子

细说Spring解决循环依赖的三级缓存

二面

• redis 常用数据结构, 实现, big key,
• 业务处理时间超过了分布式锁的过期时间, 如何处理
• mq 如何实现订单超时处理

题目1

几乎都答出来了
简单问了一下实习
Java 的hash函数是怎样的
hash函数有什么降低hash冲突的方法吗
垃圾回收算法
标记复制的缺点是什么？
标记复制为什么是8:1:1
jvm的软引用和弱引用的区别
为什么jvm会有这几种引用的区分
讲一下协程
线程和协程区别，哪个上下文切换开销大
协程的上下文切换开销主要在哪里？
协程栈大小是多大，线程呢？
springboot的优势
除了约定俗成的配置，你知道springboot在初期是怎样发展起来的吗，有什么优势
spring是如何解决循环依赖的？
三级缓存为什么能解决循环依赖

网易

一面

题目1

开局一个sql题：
登录记录表record，有字段记录id（id），用户id（user_id），登录时间（login_time），怎么查询用户A（user_id=10000）的最近3次登录记录？
写了个select * from record where user_id = 10000 order by login_time desc，忘记最近3次怎么写了（加个limit 3就行）
接下来全是场景题，感受一下：
1、服务器被入侵了如何处理？（随便答了个拉黑ip，但是换一个ip怎么办，不会）
2、发现某个接口速度很慢，如何排查？（一脸懵）
3、mysql某条语句查询速度很慢，如何排查？（说了explain查看执行计划）
4、1000w条数据找目标值，几分查找比较合适？（没懂这题想考什么，是想考B+树索引吗）

题目2

\1. 自我介绍
\2. 实习经历中的接口优化怎么做的
\3. 你是怎么检测接口速度和页面响应快慢的
\4. 合同流程优化细节
\5. 合同生成是同步还是异步调度的
\6. 防重提交怎么做的
\7. Redis分布式锁相关问题
\8. 为什么要做这样的功能
\9. 简历上面有个策略模式，你还知道哪些设计模式
\10. 讲一下单例和工厂模式
\11. 看了你的github源码，这里面为什么会有这么多文件夹—微服务，工具类打成jar包，直接用接口
\12. 是不是可以试试多模块？
\13. 各个模块之间是不是有很多关联操作
\14. 怎么创建线程
\15. 线程的拒绝策略有哪些，分别在什么场景下面能用到
\16. 你之前怎么进行项目部署的
\17. 你知道dockerfile是什么作用不
\18. 来做道题—单词拆分（leetcode 139）—大概7min
\19. 说思路—动态规划
\20. 什么时候到岗，能实习多久

新浪

一面

题目1

1.自我介绍

2.秒杀场景下redis的分布式锁和lua脚本分别起什么作用

3.缓存空对象可以解决缓存穿透，但是高并发场景下压力大怎么办

4.了解大模型吗，用大模型协助开发吗，平时用什么大模型协助开发，大模型的token是什么，怎么定义一个token

5.项目中怎么解决mq消息的重复消费和消息丢失

6.rocketmq底层怎么保证消息的可靠性（记不清问的啥了）

7.mysql的隔离级别有哪些

8.rr下一个事务能读到其他事务的提交吗

9.优化慢查询有哪些思路

10.索引分类有哪些，怎么建索引，哪些场景索引会失效

大疆

一面

题目1

1.自我介绍+项目介绍

2.ThreadLocal咱们平时用的时候，都说要注意内存泄漏，具体是怎么避免的呢?

3.聊聊Nacos吧，它的选举机制是怎么样的?跟 Raft算法有什么关系，能讲讲Raft的原理吗?

4.分库分表这个话题，你了解哪些实现方案?分了之后，分布式ID一般是怎么生成的?

5.如果我想在线程池的父子线程之间传递 ThreadLocal里的值，有什么办法吗?

6.MySQL性能调优，你一般会从哪些方面入手?有什么方法和思路?

7.布隆过滤器，能讲讲它的原理吗?在什么场景会用到它?

8.Dubbo在做RPC调用的时候，如果调用失败了，它都有哪些处理机制?比如重试、降级这些。

9.你是怎么理解线程安全这个概念的?平时在代码里是怎么处理线程安全问题的?

10.我们常说Redis单线程快，而且是线程安全的。它的线程安全具体是怎么保证的?

\11. MySQL主从同步如果出现延迟了，一般是什么原因造成的?有什么解决方案?

12.MySQL的binlog有哪几种格式?它们之间有什么区别?

13.实现分布式锁，都有哪些方案?能讲讲它们的3/4原理吗?

14.如果要你来设计一个全链路压测平台，你的设计思路是怎样的?

15.系统升级的时候，经常涉及到数据迁移，怎么才能做到平滑迁移，不影响线上业务?

16.线上服务JVM频繁Full GC，你会怎么去排查和解决?

17.数据库如果发生死锁了，一般的排查步骤是怎样的?

18.做了分库分表之后，如果某个库或表出现数据倾斜，有什么解决办法?

19.用分布式锁的时候，如果第一次加锁失败了， 4/4

后续的重试机制一般怎么设计比较合理?

20.有没有遇到过MySQL执行计划选错了索引的情况?碰到了怎么处理?

21.Spring的核心是IOC，你觉得要实现一个IOC容器，关键点有哪些?

22.Spring的声明式事务很方便，它的底层原理是什么?

23.设计一个订单超时自动取消的功能，你会怎么实现?

24.在并发编程里，线程的同步

(Synchronization)和协作(Coordination)，它俩有什么区别?

顺丰

一面

题目1

1、自我介绍
2、介绍一下你的项目的背景和自己负责的项目模块
3、结合业务对SQL优化进行讲解
4、项目中分库分表是怎么做的,常见的分库分表组件有哪些,原理
5、常见出现OOM的场景,怎么解决分析的
6、JVM垃圾回收机制,为什么大对象会导致系统OOM和CPU飙升
7、JVM使用什么方式标记这个对象回收的
8、标记对象回收使用引用计数了,为什么还需要有可达性分析技术来代替
9、项目中的订单量是多少,项目中订单相关的功能怎么实现的,详细说明一下
10、项目中如果出现消息挤压、重复消费的情况怎么解决
11、RocketMQ的原理,怎么发送消息,收到消息怎么处理
12、RocketMQ支持那几种类型的消息
13、Redis项目中具体场景是什么
14、Redis常见的数据结构
15、Redis部署方式
16、Redis为什么单线程还那么快

17、当接口速度慢,SQL比较慢,具体是怎么排除的,给出思路

招银网络

一面

题目1

ava中线程安全的集合？（只答了ConcurrentHashMap）

ConcurrentHashMap如何保证线程安全？（没答好，答了节点锁）

Object类有哪些常用的方法？（答了hashcode、equals，面试官补充还有多线程、锁相关的方法）

抽象类和接口的区别？（答设计动机不同）

模版方法模式用抽象类还是接口更好？（抽象类，因为可以直接复用方法，这题答错了确实不应该）

ArrayList和LinkedList的区别？（前者基于动态数组，后者基于链表）

什么场景用ArrayList？什么场景用LinkedList？（从性能角度分析，读多写少用前者，写多读少用后者）

JVM有哪些常用参数？（答了初始堆内存、最大堆内存）

JVM的轻GC和重GC有什么区别？（轻GC只清Eden区，重GC会清整个新生代）

如何避免重GC？（没答好，答了从程序设计的角度，少new一些对象；从JVM参数的角度，扩大堆内存）

如何避免OOM？（不知道，只说了加大堆内存）

线程池的参数？（七大核心参数）

线程池的任务队列，用有界队列和无界队列的区别？（有界队列如果满了，新任务会被拒绝，无界队列则不会）

什么场景用有界队列？什么场景用无界队列？（任何场景都不推荐用无界队列，容易OOM）

MySQL三大设计范式？（学过，忘了）

InnoDB引擎的优势？（支持事务、外键、行级锁）

乐观锁和悲观锁的区别？（乐观锁假设不发生冲突，不加锁，但修改数据时需要判断数据是否被修改过，悲观锁假设发生冲突，直接加锁）

Spring如何解决循环依赖？（三级缓存，没答上来）

Spring Bean的生命周期？（没答上来）

如何设计一个切面？（不会）

题目2

1.自我介绍+实习部分

2.项目中redis挂了怎么办

3.线程安全怎么实现？

4.synchronized和lock有什么区别

5.线程安全的容器都有哪些？

6.mysql查询优化都有哪些方式？

7.spring容器启动过程

8.你自己倾向于推送任务流程进行还是做具体的事情（比如功能开发）？

B站

一面

二面

题目1

\1. 自我介绍
\2. 介绍腾讯实习做的工作，并绘制流程图，同时解答以下疑问点：
1）这样的设计的意图是解决什么问题？
2）瓶颈不是单分区吗？没有解决关键瓶颈？
4）exporter具体是怎么导出？
5）prometheus的核心指标类型？
6）采集->聚合->上报的相关问题？
\3. 设计一个基于微服务的医患问诊系统，并解答以下问题：
1）怎么去划分系统模块？
2）结算服务会向问诊服务发请求吗？
3）结算服务和问诊服务都是用同一个库吗？结算服务该建几个表？
4）如果要异步发起结算调用怎么设计？为什么不用Kafka？
\4. 手撕责任链模式，并解答以下问题：
1）责任链模式的作用是什么？
2）责任链模式和工厂类的区别是什么？