1. 先搞清楚现在面试到底在考什么，别再盲目背题了

现在Java面试，尤其是想涨薪的中高级岗位，早就不是背几道“ArrayList和LinkedList区别”就能过关的了。面试官手里有AI工具，你背的八股文他可能比你记得还熟。现在的核心矛盾是：面试官想通过问题看你解决实际问题的思路和深度，而很多候选人还在用“题库驱动”的方式准备，导致一遇到场景题或者追问就露怯。

所以，这篇攻略的核心不是给你一份更全的题库，而是帮你建立一套应对当前面试环境的策略。这套策略适用于工作1-5年、想冲击更高薪资的Java程序员。最关键的价值在于：把零散的知识点，串联成面试官能听懂的“项目经验”和“解决方案”。你需要展示的不是“我知道”，而是“我理解为什么，并且知道在什么情况下怎么用”。

面试准备可以分为三个层次：

1. 基础层（必答项）：Java核心、并发、JVM、MySQL、Spring/Spring Boot。这部分是入场券，不能有硬伤，但回答要有亮点。
2. 场景层（区分度）：如何用上述知识解决实际问题。比如“高并发下如何保证缓存和数据库一致性”、“JVM调优你实际是怎么做的”。
3. 深度层（定薪项）：对某个领域有超出平均水平的理解。比如能说清楚AQS的完整实现脉络、MySQL的索引下推和MRR优化、Spring循环依赖的三级缓存具体流转。

接下来的内容，我会按照“场景驱动”的思路，重新梳理这些常考模块，告诉你面试官到底想听什么，以及怎么组织你的答案。

2. Java基础与并发编程：别只答特性，要答取舍和坑

Java基础问题现在问得很深，目的是判断你的代码功底和思考能力。

2.1 集合框架：HashMap是永远的焦点，但别止步于此

问到HashMap，面试官期待的是一条完整的回答链：

1. 数据结构：数组+链表/红黑树。数组索引通过(n-1) & hash计算。
2. 扩容：默认负载因子0.75，扩容时容量翻倍，重新哈希。这里要能说清楚为什么是2的幂次方（为了用位运算&代替取模%，提升效率，同时保证扩容时元素的新位置要么是原索引，要么是原索引+旧容量）。
3. 线程安全：
   • Hashtable：全表锁，性能差，已过时。
   • Collections.synchronizedMap：包装器，锁粒度大。
   • ConcurrentHashMap（JDK1.8+）：这是重点。要能说清楚它如何通过synchronized锁链表头/红黑树根节点+CAS来实现分段锁的细粒度化。put流程大致是：计算hash、定位到Node、如果为空则CAS插入、否则synchronized锁住该节点进行链表或树的操作。
4. 实际场景：你可以补充一句，“在最近的项目里，我用ConcurrentHashMap来缓存一些不常变但需要高频读取的配置信息，比如城市列表。选择它是因为读多写少，且需要保证线程安全，它的读操作是完全无锁的，性能很好。”这就把知识点拉回到了实际应用。

ArrayList vs LinkedList：别再只说“一个数组一个链表”。要能说出：

• ArrayList：随机访问O(1)，尾部增删O(1)，但中间插入删除需要移动元素，耗时为O(n)。扩容机制是核心，默认扩容1.5倍，要理解Arrays.copyOf的成本。
• LinkedList：增删O(1)（如果已知节点位置），但随机访问需要遍历，O(n)。它更消耗内存（每个节点有前后指针）。
• 场景选择：“我大部分情况用ArrayList，因为CPU缓存友好，遍历快。只有在我需要频繁在列表中间进行插入删除操作，并且不需要随机访问时，才会考虑LinkedList，比如实现一个LRU缓存的双向链表结构。”

2.2 并发编程：从synchronized到AQS，理解设计思想

并发是区分初中高级的关键。死记硬背volatile关键字没用。

synchronized的升级过程（锁膨胀）：这是必考题。要说清楚无锁 -> 偏向锁（单线程重入） -> 轻量级锁（CAS自旋，线程交替执行） -> 重量级锁（向操作系统申请互斥量，线程阻塞）的转化条件。这体现了JVM对锁的优化思想：能在用户态解决，就不进内核态。

volatile与内存屏障：volatile保证可见性和有序性（禁止指令重排序），但不保证原子性。底层是通过内存屏障（LoadLoad, StoreStore, LoadStore, StoreLoad）实现的。可以举个典型场景：“比如我们用一个volatile boolean flag作为线程退出的标志位，主线程修改flag后，工作线程能立即看到，这就是可见性。”

JUC工具包的核心：AQS：AbstractQueuedSynchronizer是ReentrantLock、CountDownLatch、Semaphore等工具的基础。不必手撕全部源码，但要理解其核心：

• 状态变量state：同步状态。
• CLH队列：一个虚拟的双向队列，用于管理等待线程。
• 模板方法模式：子类实现tryAcquire/tryRelease等方法来定义具体的同步逻辑。
• 以ReentrantLock为例：lock()方法最终调用AQS的acquire()，acquire()会先tryAcquire尝试获取锁（非公平锁会直接CAS抢一下），失败后则将当前线程包装成Node加入队列，并可能进入阻塞状态。

线程池（ThreadPoolExecutor）：七个核心参数（核心线程数、最大线程数、存活时间、时间单位、工作队列、线程工厂、拒绝策略）必须烂熟于心。常考场景：

• 队列选择：LinkedBlockingQueue无界，可能堆积导致OOM；SynchronousQueue不存储，直接传递；ArrayBlockingQueue有界。
• 拒绝策略：AbortPolicy（抛异常）、CallerRunsPolicy（调用者线程运行）、DiscardOldestPolicy（丢弃最老任务）、DiscardPolicy（直接丢弃）。
• 实际配置：“在Web项目中，我通常用ThreadPoolTaskExecutor（Spring对ThreadPoolExecutor的包装）。IO密集型任务（如网络请求）我会设置核心线程数稍大（比如CPU核数*2），队列用有界的ArrayBlockingQueue防止内存溢出，拒绝策略用CallerRunsPolicy让调用线程去执行，给系统一个缓冲。”

3. JVM与性能调优：从理论到可操作的排查

JVM问题不是为了考你背参数，而是看你在线上遇到OOM、CPU飙高、GC频繁时，有没有一套清晰的排查思路。

3.1 内存模型与GC：理解“为什么”，才能知道“怎么看”

运行时数据区：重点区分堆（Heap）和方法区（Metaspace）、栈（Stack）的关系。

• 堆：对象实例、数组。是GC的主战场，分为新生代（Eden, S0, S1）和老年代（Old）。
• 方法区：类信息、常量、静态变量。JDK8后叫元空间（Metaspace），使用本地内存。
• 栈：线程私有，存局部变量表、操作数栈、动态链接、方法出口。栈溢出（StackOverflowError）通常由无限递归引起。

垃圾回收算法与收集器：

• 算法：标记-清除（碎片化）、标记-整理（移动对象，无碎片）、复制（用于新生代，Eden和Survivor区）。
• 收集器：面试常考组合。
  • ParNew + CMS：JDK8及以前老年代常用。CMS目标是低停顿，分四步：初始标记、并发标记、重新标记、并发清除。缺点是会产生碎片，且无法处理“浮动垃圾”。
  • G1：JDK9后默认。将堆划分为多个Region，可预测停顿时间。过程是：初始标记、并发标记、最终标记、筛选回收。
  • ZGC：JDK11引入，目标是将停顿时间控制在10ms以内。核心是染色指针技术。

关键参数与日志解读： 光知道参数名不够，要能说出在什么场景下调整。

• -Xms/-Xmx：堆初始和最大大小。生产环境必须设置成一样大，避免堆震荡。
• -Xmn：新生代大小。通常占整个堆的1/3到1/2。
• -XX:MetaspaceSize/-XX:MaxMetaspaceSize：元空间大小。防止动态生成类过多导致元空间溢出。
• -XX:+PrintGCDetails：打印GC详细日志。
  • 看到[GC (Allocation Failure)...]说明发生了Young GC。
  • 看到[Full GC (Metadata GC Threshold)...]可能是Metaspace空间不足。
  • 关注指标：YGCT（Young GC总时间）、FGCT（Full GC总时间）、GCT（总GC时间）。如果Full GC频繁或单次时间长，就是严重问题。

3.2 线上问题排查实战流程

当收到报警“服务CPU 100%”或“频繁Full GC”时，你的排查步骤应该是：

1. 定位进程：top -c找到CPU或内存占用最高的Java进程PID。
2. 查看线程：top -Hp [PID]查看该进程下所有线程的资源占用。找到耗CPU的线程ID（TID）。
3. 线程转储：将TID转为16进制，然后jstack [PID] | grep -A 20 [nid=0x十六进制TID]查看该线程的堆栈信息。常见原因：死循环、频繁GC、锁竞争。
4. 内存分析：
   • jstat -gcutil [PID] 1000 10：每隔1秒打印一次GC情况，共10次。观察各分区使用率和GC次数/时间。
   • jmap -histo:live [PID] | head -20：查看堆中对象数量和大小的直方图。
   • 生成堆转储（Dump）：jmap -dump:format=b,file=heap.hprof [PID]。然后用MAT或JVisualVM分析，找到占用内存最大的对象和引用链。
5. 案例：如果jstack发现很多线程卡在java.lang.Object.wait()，可能是数据库连接池耗尽或外部服务调用超时。如果MAT分析发现是某个大HashMap或缓存对象占用了大量内存，就要检查缓存策略或是否存在内存泄漏（如监听器未取消注册）。

4. MySQL：索引、事务与优化，告别死记硬背

MySQL问题集中在如何高效、正确地使用它。

4.1 索引：理解B+树才能用好索引

为什么是B+树？对比B树，B+树的所有数据都存储在叶子节点，且叶子节点之间有指针相连。这带来了两个巨大优势：

1. 范围查询效率极高：因为叶子节点是链表，找到起点后顺序遍历即可。
2. 更适合磁盘IO：非叶子节点只存键值，不存数据，所以一个磁盘页能容纳更多索引项，树的高度更低，查询需要的IO次数更少。

聚簇索引 vs 非聚簇索引：

• 聚簇索引：InnoDB中，表数据文件本身就是按主键顺序组织的B+树索引。叶子节点存储了完整的行数据。一个表只有一个聚簇索引。
• 非聚簇索引（二级索引）：叶子节点存储的是主键值，而不是行数据。查询时，需要先查到主键，再回表到聚簇索引中查找完整数据（回表查询）。

最左前缀原则：这是组合索引使用的核心原则。对于索引(a, b, c)：

• 能生效的查询：where a=1,where a=1 and b=2,where a=1 and b=2 and c=3,where a=1 and c=3（只用到了a）。
• 不能生效或部分生效的查询：where b=2,where c=3,where b=2 and c=3。

索引失效场景（要能解释原因）：

1. 对索引列进行函数操作、计算或类型转换：where YEAR(create_time)=2023。
2. 使用!=、<>、NOT IN、NOT EXISTS。
3. LIKE以通配符开头：where name like '%张'。
4. 组合索引未遵循最左前缀。
5. 在索引列上使用OR，如果OR的每个条件列都有独立索引，可能会走索引合并，否则容易全表扫描。
6. 数据分布极度不均匀，优化器认为全表扫描更快。

4.2 事务与锁：说清楚隔离级别和锁机制

ACID与隔离级别：

• 读未提交：脏读、不可重复读、幻读都可能发生。
• 读已提交：解决脏读。这是Oracle等数据库的默认级别。
• 可重复读：解决脏读和不可重复读。这是MySQL InnoDB的默认级别。InnoDB通过MVCC（多版本并发控制）和间隙锁来解决幻读。
• 串行化：解决所有问题，但性能最差。

MVCC：核心是每行数据有两个隐藏字段：创建版本号和删除版本号。每个事务有一个唯一的事务ID。通过比较版本号来决定当前事务能看到哪个版本的数据（快照读）。这实现了非锁定读，提高了并发性能。

锁机制：

• 行锁：锁住一行。InnoDB的行锁是基于索引实现的，如果查询条件没用到索引，会升级为表锁。
• 间隙锁：锁住一个索引范围，但不包括记录本身。用于防止幻读。例如，SELECT * FROM t WHERE id BETWEEN 10 AND 20 FOR UPDATE，会锁住(10,20]这个区间，阻止其他事务插入id=15的记录。
• 临键锁：行锁+间隙锁。
• 死锁：两个事务互相等待对方释放锁。排查方法：SHOW ENGINE INNODB STATUS;查看LATEST DETECTED DEADLOCK部分。预防：尽量以相同的顺序访问多张表；在事务中更新多行数据时，按主键排序；使用较低的隔离级别（如读已提交）；设置合理的锁等待超时时间innodb_lock_wait_timeout。

优化实战建议：

• EXPLAIN是你的朋友：任何慢查询，第一反应就是用EXPLAIN查看执行计划。关注type（访问类型，至少range以上）、key（使用的索引）、rows（预估扫描行数）、Extra（Using filesort,Using temporary是危险信号）。
• 大表优化：分库分表是最后的手段。之前可以尝试：1) 归档历史数据；2) 优化索引；3) 引入读写分离；4) 使用覆盖索引减少回表。
• 连接池配置：HikariCP是首选。合理设置maximumPoolSize（通常不超过CPU核数 * 2 + 磁盘数），connectionTimeout，idleTimeout。

5. Spring生态：从会用到了解原理，应对连环问

Spring的问题往往从应用开始，层层深入到原理。

5.1 Spring Core：IoC与AOP是基石

IoC容器启动流程：可以简要描述为：Resource定位 ->BeanDefinition的载入与解析 ->BeanDefinition在容器中的注册 -> Bean的实例化与依赖注入 -> 初始化（InitializingBean,init-method）-> 销毁。

依赖注入：构造函数注入（Spring推荐，保证不可变性和完全初始化）、Setter注入、字段注入（@Autowired，不推荐，因为不利于测试和不变性）。

循环依赖：这是经典问题。Spring通过三级缓存解决Setter注入和字段注入的循环依赖。

1. 一级缓存singletonObjects：存放完整的单例Bean。
2. 二级缓存earlySingletonObjects：存放提前暴露的、未完全初始化的Bean（早期引用）。
3. 三级缓存singletonFactories：存放Bean的工厂对象，用于生成早期引用。

• 流程：A创建 -> 将自己工厂放入三级缓存 -> 发现依赖B -> 创建B -> B发现自己依赖A -> 从三级缓存拿到A的工厂，生成A的早期引用放入二级缓存 -> B完成初始化 -> A注入B，完成初始化 -> A从二级缓存移除，放入一级缓存。
• 注意：构造函数注入的循环依赖无法解决，因为构造时就需要完整的依赖对象。

AOP：理解代理模式。Spring AOP默认使用JDK动态代理（基于接口）和CGLIB代理（基于类继承）。要知道切面表达式@Pointcut的写法，以及通知类型：@Before,@After,@AfterReturning,@AfterThrowing,@Around。

5.2 Spring Boot与Spring Cloud

Spring Boot自动配置原理：核心是@SpringBootApplication注解，它组合了@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan。

• @EnableAutoConfiguration通过@Import(AutoConfigurationImportSelector.class)导入配置。
• AutoConfigurationImportSelector会读取META-INF/spring.factories文件中的org.springframework.boot.autoconfigure.EnableAutoConfiguration配置项，加载大量的自动配置类。
• 每个自动配置类通常带有@ConditionalOnClass,@ConditionalOnMissingBean等条件注解，根据类路径下是否存在某个类、容器中是否已有某个Bean来决定是否生效。

Spring Boot Starter：本质上是一个Maven依赖，它聚合了某个功能所需的所有依赖和自动配置。例如，spring-boot-starter-web包含了Tomcat、Spring MVC等。

Spring Cloud核心组件（了解即可，除非面专精微服务的岗位）：

• 服务注册与发现：Eureka（已停更）、Nacos（推荐）。
• 负载均衡：Ribbon（客户端负载均衡，已停更）、Spring Cloud LoadBalancer。
• 服务调用：OpenFeign（声明式HTTP客户端）。
• 网关：Spring Cloud Gateway（基于WebFlux，性能好）。
• 配置中心：Spring Cloud Config、Nacos Config。
• 熔断与降级：Resilience4j、Sentinel。

面试场景题举例：

• “你们的服务是怎么部署的？”：可以谈Docker + Kubernetes，或者简单的Jar包部署。重点说清楚CI/CD流程、健康检查、滚动更新策略。
• “如何保证微服务之间的数据一致性？”：引出分布式事务，可以说最终一致性方案，如本地消息表、可靠消息队列（RocketMQ事务消息）、Saga模式。强调在大多数业务场景下，追求强一致性成本太高，最终一致性是更务实的选择。
• “如何排查一个线上接口慢的问题？”：这是一个综合题。可以从链路入手：网关/负载均衡 -> 服务本身（查线程栈、查慢SQL、查远程调用）-> 数据库/缓存/第三方服务。工具链：SkyWalking、Pinpoint做链路追踪；Arthas在线诊断；前面提到的JVM/MySQL排查工具。

6. 场景题与项目经验：把技术栈讲成故事

这是面试中最能体现你价值的部分。你需要准备1-2个自己深度参与的项目，用“STAR”法则（情境、任务、行动、结果）来组织描述。

如何准备项目描述：

1. 选对项目：选一个你熟悉、有技术亮点、最好能体现你解决问题能力的项目。不一定是大项目，但你要能说清楚。
2. 提炼亮点：从项目中提炼出2-3个技术点，比如“我用Redis分布式锁解决了超卖问题”、“我通过调整JVM参数和SQL优化，将接口响应时间从2s降到200ms”、“我设计了分库分表方案来支撑亿级用户数据”。
3. 深挖细节：针对每个亮点，准备被追问。比如你说了用Redis锁，面试官可能会问：
   • 为什么用Redis而不用ZooKeeper或数据库锁？（性能、实现复杂度）
   • 锁的过期时间怎么设置的？设置太短或太长有什么问题？
   • 如何避免锁被其他线程释放？（value存唯一标识，如UUID+线程ID，释放时先比对）
   • 如果业务执行时间超过锁过期时间怎么办？（引入看门狗机制，自动续期）
   • 集群环境下，主从切换可能导致锁失效，怎么办？（RedLock算法，或用Redisson客户端）

高频场景题思路：

• “如何设计一个秒杀系统？”这是一个经典的综合题。回答分层：
  1. 前端：静态化页面、按钮防重复提交、验证码。
  2. 网关/负载均衡：限流、恶意请求拦截。
  3. 服务层：业务逻辑尽量前置校验、库存扣减用Redis预扣（Lua脚本保证原子性）、请求排队（MQ削峰填谷）、热点数据缓存。
  4. 数据库：库存扣减最终落地，可能用到乐观锁。数据库本身要做读写分离、分库分表。
  5. 兜底：熔断、降级、监控告警。
• “缓存与数据库双写一致性问题”：先说几种方案及其优缺点。
  • 先更新数据库，再删除缓存（Cache-Aside）：常用，但存在小概率的脏读（更新DB后，删缓存前，有读请求把旧数据又塞回缓存）。可以通过设置缓存过期时间或延迟双删来缓解。
  • 先删除缓存，再更新数据库：问题更大，在删除缓存后、更新DB前，另一个读请求可能把旧数据读到缓存。
  • 串行化：通过MQ或binlog订阅（如Canal）异步更新缓存，保证最终一致性。这是比较重的方案。
  • 结论：没有完美方案。在要求强一致性的金融场景，可能直接读库。在大多数互联网场景，采用“先更新DB，再删缓存”，并接受极短时间的不一致，用缓存的过期时间来兜底。

7. 面试策略与心态：把面试当成一次技术交流

最后，说点实战心态和技巧。

面试前：

1. 简历打磨：项目经历按STAR法则写，突出你的行动和结果。技术栈写熟悉的，不熟的别写。
2. 针对性复习：根据目标公司的业务和技术栈（可以去招聘网站看JD），有侧重地复习。比如面电商，重点准备高并发、分布式事务；面中间件团队，重点准备JVM、网络、源码。
3. 模拟面试：找朋友或自己录音，模拟回答常见问题，控制语速和逻辑。

面试中：

1. 听清问题：没听明白或不确定的问题，一定要确认。“您问的是不是关于XXX方面的问题？”
2. 结构化回答：对于复杂问题，先说结论或核心观点，再分点阐述。“这个问题可以从三个方面来看，第一…第二…第三…”
3. 诚实：遇到不会的，直接说“这个领域我了解不深”，但可以尝试基于已有知识推理一下，展现思考过程。切忌不懂装懂。
4. 主动引导：在回答完问题后，如果相关，可以补充一句：“关于这个问题，我们在之前的XXX项目中，采用了YYY方案，原因是…”，把话题引向你熟悉的领域。
5. 提问环节：准备几个有深度的问题，比如“团队目前面临的主要技术挑战是什么？”、“这个岗位的核心考核指标是怎样的？”、“团队的技术栈和未来的技术规划？”。这体现了你的思考和对机会的重视。

面试后：无论成败，及时复盘。记录下被问倒的问题，回去查资料搞懂。每一次面试都是对自身技术体系的一次检验和升级。

记住，在AI辅助面试官的时代，你的优势在于系统的思考、清晰的表达和解决真实问题的经验。把零散的知识点，通过项目经验和场景思考串联起来，形成你自己的“技术叙事”，这才是打动面试官、实现涨薪的关键。