Java 面试知识点串联指南
核心理念：用"从代码到架构"的纵向主线，把分散的知识点串成网
📌 一、核心串联主线
五层递进模型
┌─────────────────────────────────────────┐
│ 5. 架构层：微服务、缓存、消息队列 │
├─────────────────────────────────────────┤
│ 4. 框架层：Spring、MyBatis、SpringBoot │
├─────────────────────────────────────────┤
│ 3. 并发层：锁、线程池、JUC │
├─────────────────────────────────────────┤
│ 2. JVM 层：内存模型、GC、类加载 │
├─────────────────────────────────────────┤
│ 1. 基础层：集合、IO、反射、泛型 │
└─────────────────────────────────────────┘串联方法：从一行代码出发，逐层深入
java
// 从一个简单的 HashMap 出发
Map<String, Object> cache = new HashMap<>();
// 问题链：
// 1. 基础层：HashMap 底层结构？扩容机制？
// 2. 并发层：线程安全吗？ConcurrentHashMap 如何实现？
// 3. JVM 层：存太多会怎样？触发什么 GC？
// 4. 框架层：Spring 哪里用了 HashMap？
// 5. 架构层：分布式缓存怎么选？Redis vs 本地缓存？📌 二、七大知识串（完整梳理）
🔹 知识串 1：集合框架 → 并发容器
Collection 接口
├── List
│ ├── ArrayList（数组，随机访问 O(1)）
│ │ └── 扩容：1.5 倍，System.arraycopy
│ ├── LinkedList（双向链表，插入删除 O(1)）
│ └── Vector（线程安全，已过时）→ CopyOnWriteArrayList
├── Set
│ ├── HashSet（HashMap + PRESENT）
│ ├── LinkedHashSet（维护插入顺序）
│ └── TreeSet（红黑树，自然/比较器排序）
└── Queue
├── PriorityQueue（堆实现）
└── ArrayBlockingQueue（阻塞队列）
Map 接口
├── HashMap（重点！）
│ ├── JDK7：数组 + 链表，头插法
│ ├── JDK8：数组 + 链表 + 红黑树，尾插法
│ ├── 负载因子：0.75，阈值 = 容量 × 负载因子
│ ├── hash 计算：(h >>> 16) ^ h
│ └── 树化条件：链表长度≥8 且数组长度≥64
├── ConcurrentHashMap（高频！）
│ ├── JDK7：Segment 分段锁
│ ├── JDK8：Node + synchronized + CAS
│ └── 不支持 null key/value
├── LinkedHashMap（LRU 基础）
│ └── 双向链表维护顺序
└── TreeMap（红黑树）面试串联答法：
问：HashMap 和 ConcurrentHashMap 的区别？
- 结构差异：HashMap 是数组 + 链表 + 红黑树；CHM 在此基础上加了并发控制
- 线程安全：HashMap 不安全；CHM 用 synchronized+CAS 保证
- null 值：HashMap 允许 null；CHM 不允许
- 场景：单线程用 HashMap，多线程用 CHM
🔹 知识串 2：并发编程完整链路
┌─────────────────────────────────────────────────────────────┐
│ 并发编程知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① 基础概念 │
│ 进程 vs 线程 → 线程状态 (NEW/RUNNABLE/BLOCKED/ │
│ WAITING/TIMED_WAITING/TERMINATED) │
│ │
│ ② 三大特性 │
│ 原子性 → 操作不可分割 │
│ 可见性 → volatile、synchronized │
│ 有序性 → happens-before、指令重排 │
│ │
│ ③ 关键字详解 │
│ volatile │
│ ├── 保证可见性（MESI 缓存一致性协议） │
│ ├── 保证有序性（禁止指令重排） │
│ └── 不保证原子性（需配合 CAS） │
│ │
│ synchronized │
│ ├── 对象头 Mark Word（哈希码 + GC 分代年龄 + 锁标志） │
│ ├── 锁升级：无锁 → 偏向锁 → 轻量级锁 → 重量级锁 │
│ └── Monitor 机制（进入/退出） │
│ │
│ ④ JUC 工具类 │
│ ReentrantLock │
│ ├── AQS（AbstractQueuedSynchronizer）核心 │
│ ├── CLH 双向队列 │
│ ├── state 字段表示锁状态 │
│ └── fair vs non-fair │
│ │
│ CountDownLatch / CyclicBarrier / Semaphore │
│ │
│ ⑤ CAS 与原子类 │
│ Compare-And-Swap │
│ ├── 三个操作数：内存位置 V、预期值 A、更新值 B │
│ ├── ABA 问题 → 版本号解决 │
│ └── AtomicXXX 类 │
│ │
│ ⑥ 线程池（超高频！） │
│ ThreadPoolExecutor │
│ ├── 7 大参数 │
│ │ corePoolSize - 核心线程数 │
│ │ maximumPoolSize - 最大线程数 │
│ │ keepAliveTime - 空闲存活时间 │
│ │ unit - 时间单位 │
│ │ workQueue - 任务队列 │
│ │ threadFactory - 线程工厂 │
│ │ handler - 拒绝策略 │
│ ├── 工作流程 │
│ │ 新任务 → 核心线程？创建 → 满了？入队 → │
│ │ 队列满？非核心线程？创建 → 全部满？拒绝 │
│ └── 4 种拒绝策略 │
│ AbortPolicy（抛异常）、CallerRuns（调用者运行） │
│ DiscardPolicy（丢弃）、DiscardOldest（丢弃最老） │
│ │
│ ⑦ ThreadLocal │
│ ├── 线程隔离变量 │
│ ├── ThreadLocalMap（弱引用 Entry） │
│ └── 内存泄漏：必须 remove() │
│ │
└─────────────────────────────────────────────────────────────┘执行流程串联：
任务提交到线程池
↓
检查核心线程是否已满
↓ 未满
创建新核心线程执行
↓ 已满
尝试加入阻塞队列
↓ 队列满
检查最大线程是否已满
↓ 未满
创建非核心线程执行
↓ 已满
执行拒绝策略🔹 知识串 3：JVM 完整体系
┌─────────────────────────────────────────────────────────────┐
│ JVM 知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① 内存区域（JDK8） │
│ ┌──────────────────────────────────────┐ │
│ │ JVM 内存结构 │ │
│ ├──────────────────────────────────────┤ │
│ │ 堆 (Heap) │ 线程共享 │ │
│ │ ├─ 新生代 │ - Eden │ │
│ │ │ │ - Survivor0/1 │ │
│ │ ├─ 老年代 │ │ │
│ │ └─ (JDK7:方法区在堆中) │ │
│ ├──────────────────────────────────────┤ │
│ │ 方法区 (Metaspace) │ 线程共享 │ │
│ │ - 类信息、常量、静态变量 │ │
│ │ - JDK8 后使用本地内存 │ │
│ ├──────────────────────────────────────┤ │
│ │ 栈 (Stack) │ 线程私有 │ │
│ │ - 栈帧（局部变量表 + 操作数栈） │ │
│ │ - 方法执行与调用 │ │
│ ├──────────────────────────────────────┤ │
│ │ 程序计数器 │ 线程私有 │ │
│ │ - 记录当前执行的字节码行号 │ │
│ └──────────────────────────────────────┘ │
│ │
│ ② 垃圾回收 │
│ 判断对象存活 │
│ ├── 引用计数法（循环引用问题） │
│ └── 可达性分析（GC Roots） │
│ ├── 虚拟机栈引用的对象 │
│ ├── 方法区中类静态属性引用的对象 │
│ ├── 方法区中常量引用的对象 │
│ └── 本地 JNI 栈引用的对象 │
│ │
│ GC 算法 │
│ ├── 标记 - 清除（碎片问题） │
│ ├── 标记 - 复制（新生代，Survivor） │
│ ├── 标记 - 整理（老年代） │
│ └── 分代收集（主流） │
│ │
│ 垃圾收集器 │
│ ├── CMS（老年代，标记 - 清除，低停顿） │
│ ├── G1（Region 分区，可预测停顿） │
│ └── ZGC（JDK11+，超低停顿<10ms） │
│ │
│ ③ 类加载机制 │
│ 加载 → 验证 → 准备 → 解析 → 初始化 │
│ │
│ 双亲委派模型 │
│ ├── Bootstrap ClassLoader（启动类加载器） │
│ ├── Extension ClassLoader（扩展类加载器） │
│ └── Application ClassLoader（应用类加载器） │
│ │
│ 打破双亲委派 │
│ ├── SPI 机制（ServiceLoader） │
│ ├── Tomcat（自定义 WebAppClassLoader） │
│ └── 热部署/热替换 │
│ │
│ ④ 性能调优 │
│ 常用命令 │
│ ├── jps - 查看 JVM 进程 │
│ ├── jstat - 监控 GC 统计 │
│ ├── jmap - 生成堆 dump │
│ ├── jhat - 分析堆 dump │
│ └── jstack - 查看线程栈 │
│ │
│ 常见参数 │
│ ├── -Xms/-Xmx 堆初始/最大大小 │
│ ├── -Xmn 新生代大小 │
│ ├── -XX:NewRatio 新老比例 │
│ ├── -XX:+UseG1GC 使用 G1 收集器 │
│ └── -XX:MaxGCPauseMillis 目标停顿时间 │
│ │
└─────────────────────────────────────────────────────────────┘GC 过程串联：
对象在 Eden 区分配
↓
Eden 满，触发 Minor GC
↓
存活对象复制到 Survivor0
↓
再次 GC，Survivor0 存活对象复制到 Survivor1
↓
每次复制年龄 +1，达到阈值（默认 15）晋升老年代
↓
老年代满，触发 Full GC（可能伴随 Minor GC）🔹 知识串 4：Spring 全家桶
┌─────────────────────────────────────────────────────────────┐
│ Spring 知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① Spring Framework（核心） │
│ │
│ IOC（控制反转） │
│ ├── 依赖注入的三种方式 │
│ │ ├── 构造器注入 │
│ │ ├── Setter 注入 │
│ │ └── 注解注入（@Autowired、@Resource） │
│ │ │
│ ├── Bean 生命周期（背诵！） │
│ │ 实例化 → 属性填充 → Aware 回调 → │
│ │ BeanPostProcessor 前置 → 初始化 → │
│ │ BeanPostProcessor 后置 → 使用 → 销毁 │
│ │ │
│ ├── 循环依赖解决 │
│ │ 三级缓存：singletonFactories、 │
│ │ earlySingletonObjects、singletonObjects │
│ │ 仅支持 setter 注入的循环依赖 │
│ │ │
│ └── Bean 作用域 │
│ singleton（默认）、prototype、 │
│ request、session、global-session │
│ │
│ AOP（面向切面） │
│ ├── 应用场景：日志、事务、权限、性能监控 │
│ ├── 动态代理 │
│ │ ├── JDK 动态代理（基于接口，Proxy.newProxyInstance） │
│ │ └── CGLIB（基于继承，ASM 字节码技术） │
│ ├── 通知类型 │
│ │ Before、After、AfterReturning、 │
│ │ AfterThrowing、Around（功能最强） │
│ └── @AspectJ 注解 │
│ │
│ ② Spring Boot │
│ │
│ 自动装配原理（必考！） │
│ ├── @SpringBootApplication │
│ │ ├── @SpringBootConfiguration │
│ │ ├── @ComponentScan │
│ │ └── @EnableAutoConfiguration │
│ │ │
│ ├── @EnableAutoConfiguration │
│ │ └── @Import(AutoConfigurationImportSelector.class) │
│ │ └── 读取 META-INF/spring.factories │
│ │ └── 加载所有自动配置类 │
│ │ │
│ └── 按需装配：@ConditionalOnClass 等条件注解 │
│ │
│ Starter 机制 │
│ ├── spring-boot-starter-web │
│ ├── spring-boot-starter-data-jpa │
│ └── 自定义 starter │
│ │
│ ③ Spring MVC │
│ │
│ 请求处理流程 │
│ 请求 → DispatcherServlet → HandlerMapping → │
│ Controller → ModelAndView → ViewResolver → 视图 │
│ │
│ 常用注解 │
│ @Controller、@RestController、@RequestMapping、 │
│ @GetMapping、@PostMapping、@RequestBody、 │
│ @ResponseBody、@PathVariable、@RequestParam │
│ │
│ ④ Spring Transaction │
│ │
│ 事务传播行为（7 种） │
│ ├── REQUIRED（默认）：有则加入，无则新建 │
│ ├── REQUIRES_NEW：挂起当前，新建事务 │
│ ├── SUPPORTS：有则加入，无则以非事务运行 │
│ ├── NOT_SUPPORTED：以非事务运行，挂起当前 │
│ ├── MANDATORY：必须有，否则抛异常 │
│ ├── NEVER：必须没有，否则抛异常 │
│ └── NESTED：嵌套事务 │
│ │
│ 事务失效场景 │
│ ├── 方法非 public │
│ ├── 自调用（this 调用） │
│ ├── 异常被 try-catch 吃掉 │
│ ├── 数据库引擎不支持（如 MyISAM） │
│ └── 回滚异常类型不匹配 │
│ │
│ ⑤ MyBatis │
│ │
│ #{} vs ${} │
│ ├── #{}：预编译，防止 SQL 注入 │
│ └── ${}：字符串替换，有注入风险 │
│ │
│ 一级缓存 & 二级缓存 │
│ ├── 一级：SqlSession 级别（默认开启） │
│ └── 二级：Mapper 级别（需配置开启） │
│ │
│ 插件机制 │
│ └── 拦截四大对象：Executor、StatementHandler、 │
│ ParameterHandler、ResultSetHandler │
│ │
└─────────────────────────────────────────────────────────────┘🔹 知识串 5：MySQL 数据库
┌─────────────────────────────────────────────────────────────┐
│ MySQL 知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① 索引（超高频！） │
│ │
│ 数据结构 │
│ ├── B+ 树（主流） │
│ │ ├── 非叶子节点只存索引 │
│ │ ├── 叶子节点存数据，有序链表连接 │
│ │ └── 适合范围查询 │
│ ├── B 树 │
│ │ └── 每个节点都存数据 │
│ ├── Hash（等值查询快，不支持范围） │
│ └── R-Tree（空间索引） │
│ │
│ 索引分类 │
│ ├── 聚簇索引（主键索引，数据物理存储） │
│ ├── 非聚簇索引（二级索引，叶子节点存主键） │
│ ├── 联合索引（覆盖索引、最左前缀原则） │
│ └── 全文索引 │
│ │
│ 最左前缀原则 │
│ 联合索引 (a,b,c)： │
│ ✓ a=1 AND b=2 AND c=3 走索引 │
│ ✓ a=1 AND b=2 走索引 │
│ ✓ a=1 走索引 │
│ ✗ b=2 AND c=3 不走索引 │
│ ✗ c=3 不走索引 │
│ │
│ 索引失效场景 │
│ ├── LIKE '%xxx'（前缀模糊） │
│ ├── 索引列上计算或函数操作 │
│ ├── 类型隐式转换（字符串不加引号） │
│ ├── OR 连接，一边没索引 │
│ └── 违反最左前缀 │
│ │
│ ② 事务与锁 │
│ │
│ ACID 特性 │
│ ├── 原子性（Atomicity）- undo log 保证 │
│ ├── 一致性（Consistency） │
│ ├── 隔离性（Isolation）- MVCC + 锁保证 │
│ └── 持久性（Durability）- redo log 保证 │
│ │
│ 隔离级别（4 种） │
│ ├── READ UNCOMMITTED（读未提交）- 脏读 │
│ ├── READ COMMITTED（读已提交）- Oracle 默认 │
│ ├── REPEATABLE READ（可重复读）- MySQL 默认，MVCC │
│ └── SERIALIZABLE（串行化） │
│ │
│ MVCC（多版本并发控制） │
│ ├── ReadView（可见性视图） │
│ ├── 隐藏字段：DB_TRX_ID、DB_ROLL_PTR │
│ └── RC 每次 select 生成 ReadView，RR 首次 select 生成 │
│ │
│ 锁分类 │
│ ├── 粒度：全局锁、表锁、行锁（记录锁、间隙锁、临键锁） │
│ ├── 类型：共享锁（S）、排他锁（X） │
│ └── 意向锁：IS（意向共享）、IX（意向排他） │
│ │
│ ③ SQL 优化 │
│ │
│ EXPLAIN 关键字段 │
│ ├── type：system > const > eq_ref > ref > range > index > ALL
│ ├── key：实际使用的索引 │
│ ├── rows：扫描行数（越少越好） │
│ └── Extra：Using filesort（需优化）、Using temporary │
│ │
│ 优化技巧 │
│ ├── SELECT 只取需要的列，避免 SELECT * │
│ ├── 小表驱动大表（EXISTS 优于 IN） │
│ ├── 避免 WHERE 子句 NULL 值判断 │
│ ├── UNION ALL 替代 UNION（不去重更快） │
│ └── 适当使用覆盖索引 │
│ │
│ ④ 日志系统 │
│ │
│ redo log（重做日志） │
│ ├── InnoDB 特有，记录"什么数据被修改" │
│ ├── 循环写入，固定大小 │
│ └── 崩溃恢复保证持久性 │
│ │
│ undo log（回滚日志） │
│ ├── 记录"相反操作"，用于回滚和 MVCC │
│ └── 事务提交后可清理 │
│ │
│ binlog（二进制日志） │
│ ├── Server 层，所有引擎可用 │
│ ├── 追加写入，用于主从复制和数据恢复 │
│ └── 两种格式：STATEMENT、ROW │
│ │
│ 两阶段提交 │
│ Prepare 阶段 → 写 redo log → binlog → Commit 阶段 │
│ （保证 redo log 和 binlog 一致性） │
│ │
└─────────────────────────────────────────────────────────────┘🔹 知识串 6：Redis 缓存
┌─────────────────────────────────────────────────────────────┐
│ Redis 知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① 数据结构（5 种基础 + 3 种高级） │
│ │
│ String（字符串） │
│ ├── 二进制安全，最大 512MB │
│ ├── 应用：缓存、计数器、分布式锁 │
│ └── 命令：SET/GET/INCR/DECR/MSET/MGET │
│ │
│ List（列表） │
│ ├── 双向链表实现 │
│ ├── 应用：消息队列、最新列表 │
│ └── 命令：LPUSH/RPOP/BRPOP │
│ │
│ Hash（哈希） │
│ ├── 键值对集合，适合存储对象 │
│ └── 命令：HSET/HGET/HGETALL/HDEL │
│ │
│ Set（集合） │
│ ├── 无序去重集合，支持交集并集差集 │
│ └── 应用：标签、好友关系 │
│ │
│ ZSet（有序集合） │
│ ├── 带分数的 Set，按分数排序 │
│ ├── 跳表实现 │
│ └── 应用：排行榜 │
│ │
│ Bitmap（位图） │
│ ├── 按 bit 操作，节省空间 │
│ └── 应用：签到统计、在线状态 │
│ │
│ HyperLogLog（基数统计） │
│ ├── 固定 12KB，允许 0.81% 误差 │
│ └── 应用：UV 统计 │
│ │
│ Geo（地理位置） │
│ └── 应用：附近的人、距离计算 │
│ │
│ ② 持久化 │
│ │
│ RDB（快照） │
│ ├── fork 子进程，copy-on-write │
│ ├── 优点：文件紧凑、恢复快 │
│ └── 缺点：可能丢失最后一次快照后的数据 │
│ │
│ AOF（追加日志） │
│ ├── 记录每条写命令 │
│ ├── fsync 策略：always/everysec/no │
│ ├── 优点：数据更安全 │
│ └── 缺点：文件大、恢复慢 │
│ │
│ 混合持久化（Redis 4.0+） │
│ └── RDB 快照 + AOF 增量 │
│ │
│ ③ 高可用架构 │
│ │
│ 主从复制 │
│ ├── 全量复制：RDB 传输 │
│ ├── 增量复制：replication buffer │
│ └── 读写分离：主写从读 │
│ │
│ 哨兵模式（Sentinel） │
│ ├── 监控、选主、故障转移 │
│ └── 主观下线 → 客观下线 → 投票 → 选主 │
│ │
│ Redis Cluster（集群） │
│ ├── 去中心化，16384 个槽 │
│ ├── 客户端直连真实节点 │
│ └── MOVED 重定向、ASK 迁移 │
│ │
│ ④ 缓存三兄弟（必考！） │
│ │
│ 缓存穿透 │
│ ├── 问题：查询不存在的数据，直接打穿到 DB │
│ └── 解决：布隆过滤器、缓存空值 │
│ │
│ 缓存击穿 │
│ ├── 问题：热点 key 过期，大量请求瞬间打到 DB │
│ └── 解决：互斥锁、逻辑过期 │
│ │
│ 缓存雪崩 │
│ ├── 问题：大量 key 同时过期，DB 压力激增 │
│ └── 解决：随机过期时间、限流降级 │
│ │
│ ⑤ 内存淘汰策略 │
│ │
│ noeviction：不淘汰，写满报错 │
│ allkeys-lru：所有 key 用 LRU 淘汰（推荐） │
│ volatile-lru：设置了过期时间的用 LRU │
│ allkeys-random：随机淘汰 │
│ volatile-ttl：按剩余 TTL 淘汰 │
│ volatile-random：过期 key 中随机 │
│ │
└─────────────────────────────────────────────────────────────┘🔹 知识串 7：分布式与微服务
┌─────────────────────────────────────────────────────────────┐
│ 分布式与微服务知识体系 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ① CAP 与 BASE │
│ │
│ CAP 定理 │
│ ├── Consistency（强一致性） │
│ ├── Availability（高可用性） │
│ └── Partition tolerance（分区容错性） │
│ └── 三者最多取其二（CP 或 AP） │
│ │
│ BASE 理论 │
│ ├── Basically Available（基本可用） │
│ ├── Soft state（软状态） │
│ └── Eventually consistent（最终一致） │
│ │
│ ② 分布式 ID │
│ │
│ UUID │
│ ├── 优点：本地生成，性能好 │
│ └── 缺点：无序，不适合主键 │
│ │
│ 雪花算法（Snowflake） │
│ ├── 64bit：符号位 (1) + 时间戳 (41) + 机器 ID(10) + 序列号 (12)
│ └── 优点：有序、高效 │
│ │
│ 号段模式 │
│ └── 数据库批量获取 ID 段 │
│ │
│ ③ 分布式锁 │
│ │
│ Redis 实现 │
│ ├── SETNX key value（原子操作） │
│ ├── 加过期时间防死锁 │
│ ├── Redlock 多锁方案 │
│ └── Watch Dog 自动续期（Redisson） │
│ │
│ ZooKeeper 实现 │
│ ├── 创建临时有序节点 │
│ └── 监听前一个节点 │
│ │
│ 数据库实现 │
│ └── 唯一索引乐观锁 │
│ │
│ ④ 分布式事务 │
│ │
│ 2PC（两阶段提交） │
│ ├── 准备阶段 → 提交/回滚阶段 │
│ └── 缺点：同步阻塞、单点故障 │
│ │
│ TCC（Try-Confirm-Cancel） │
│ ├── 业务层实现三个接口 │
│ └── 优点：性能较好，缺点：代码侵入 │
│ │
│ 本地消息表 │
│ ├── 消息与业务在同一本地事务 │
│ └── 定时任务轮询发送 │
│ │
│ RocketMQ 事务消息 │
│ ├── 半消息 → 执行本地事务 → 确认 │
│ └── 回查机制兜底 │
│ │
│ Seata │
│ ├── AT 模式（基于 2PC 改进） │
│ ├── TCC 模式 │
│ └── Saga 模式（长事务） │
│ │
│ ⑤ Spring Cloud 组件 │
│ │
│ 服务注册与发现 │
│ ├── Eureka（已停更，AP） │
│ ├── Nacos（阿里，支持 CP/AP 切换） │
│ └── Consul（HashiCorp，CP） │
│ │
│ 负载均衡 │
│ ├── Ribbon（客户端） │
│ └── LoadBalancer │
│ │
│ 服务调用 │
│ ├── OpenFeign（声明式 HTTP 客户端） │
│ └── Dubbo（RPC 框架） │
│ │
│ 熔断降级 │
│ ├── Hystrix（已停更） │
│ ├── Sentinel（阿里，功能更强） │
│ └── Resilience4j │
│ │
│ 网关 │
│ ├── Zuul（一代，阻塞 IO） │
│ └── Gateway（二代，WebFlux 异步） │
│ │
│ 配置中心 │
│ ├── Spring Cloud Config │
│ └── Nacos Config │
│ │
│ ⑥ 消息队列（MQ） │
│ │
│ 应用场景 │
│ ├── 异步解耦 │
│ ├── 流量削峰 │
│ └── 延迟队列 │
│ │
│ Kafka │
│ ├── 高吞吐，日志持久化 │
│ └── 应用：大数据、日志采集 │
│ │
│ RabbitMQ │
│ ├── AMQP 协议，可靠性高 │
│ └── 应用：订单、支付 │
│ │
│ RocketMQ │
│ ├── 阿里开源，支持事务消息 │
│ └── 应用：电商交易 │
│ │
│ 消息可靠性 │
│ ├── 生产者确认（confirm/callback） │
│ ├── 消费者 ack 机制 │
│ └── 死信队列 + 重试机制 │
│ │
└─────────────────────────────────────────────────────────────┘📌 三、面试答题模板：三层递进法
模板结构
第一层：是什么（What）
- 一句话定义概念
第二层：怎么用（How）
- 基本用法/API
- 典型应用场景
第三层：为什么（Why）
- 底层原理
- 与其他技术对比
- 扩展思考实战示例
例 1：请说说 volatile 关键字
【第一层 - 是什么】
volatile 是 Java 中的轻量级同步关键字，用于保证变量的
可见性和有序性，但不保证原子性。
【第二层 - 怎么用】
典型用法有两个：
1. 状态标记：private volatile boolean running;
2. 双重检查锁（DCL）单例模式
【第三层 - 为什么】
原理层面：
- 可见性：通过 Lock 前缀指令，强制将修改立即写回主内存
- 有序性：通过内存屏障禁止指令重排
- 不保证原子性：++操作仍是三步（读 - 改 - 写）
对比延伸：
- 相比 synchronized，volatile 更轻量但功能有限
- 原子性需求可用 AtomicXXX 类（基于 CAS）例 2：请讲讲 Spring 事务
【第一层 - 是什么】
Spring 事务是基于 AOP 实现的声明式事务管理，
通过@Transactional 注解简化开发。
【第二层 - 怎么用】
使用方式：
1. 开启事务：@EnableTransactionManagement
2. 标注方法：@Transactional
3. 常用属性：propagation、isolation、rollbackFor
典型场景：
- 转账操作：多步数据库操作需要原子性
- 批量插入：要么全成功要么全失败
【第三层 - 为什么】
原理层面：
- AOP 拦截：BeanPostProcessor 生成代理对象
- 事务管理器：PlatformTransactionManager 抽象
- 绑定机制：ThreadLocal 绑定 Connection
失效场景（加分项）：
1. 方法非 public
2. 同类自调用（this.xxx()）
3. 异常被 try-catch 吃掉
4. 数据库引擎不支持（MyISAM）
传播机制（7 种）：
- REQUIRED（默认）：有则加入，无则新建
- REQUIRES_NEW：挂起当前，新建事务
- ...📌 四、记忆技巧
1. 数字归纳法
| 数字 | 知识点 |
|---|---|
| 3 | 三大特性（原子、可见、有序） |
| 4 | 4 种引用类型、4 种隔离级别 |
| 5 | 5 种基础数据结构、5 种状态 |
| 6 | HashMap 扩容 2 次幂、6 种锁 |
| 7 | 线程池 7 参数、事务 7 传播 |
| 8 | JDK8 新特性、方法区 Metaspace |
2. 对比记忆法
| 对比项 | ArrayList | LinkedList |
|---|---|---|
| 底层结构 | 数组 | 双向链表 |
| 随机访问 | O(1) | O(n) |
| 插入删除 | O(n) | O(1) |
| 适用场景 | 读多写少 | 写多读少 |
3. 流程图记忆
HashMap put 流程：
计算 hash → 定位桶位置 → 桶空？创建 Node
↓ 桶不空
覆盖 or 链表追加
↓ 链表长度≥8
树化（数组长度≥64）or 扩容
↓ 达到阈值
扩容 → rehash → 迁移📌 五、复习优先级
| 优先级 | 模块 | 核心考点 | 建议时长 |
|---|---|---|---|
| ⭐⭐⭐ | 集合 | HashMap、ConcurrentHashMap | 2 天 |
| ⭐⭐⭐ | 并发 | 线程池、锁、AQS、volatile | 4 天 |
| ⭐⭐⭐ | JVM | 内存模型、GC、类加载 | 3 天 |
| ⭐⭐⭐ | Spring | IOC、AOP、事务、Boot 自动装配 | 4 天 |
| ⭐⭐ | MySQL | 索引、事务、锁、SQL 优化 | 3 天 |
| ⭐⭐ | Redis | 数据结构、持久化、缓存问题 | 2 天 |
| ⭐ | 微服务 | Spring Cloud、MQ、分布式锁 | 3 天 |
| ⭐ | 项目 | 自我介绍、项目难点、技术选型 | 2 天 |
📌 六、考前速记清单
JVM 必背
- [ ] 内存区域划分（堆、栈、方法区）
- [ ] GC Roots 有哪些
- [ ] G1 vs CMS 区别
- [ ] 双亲委派模型
并发必背
- [ ] volatile 三大特性
- [ ] 线程池 7 参数 + 工作流程
- [ ] synchronized 锁升级过程
- [ ] AQS 核心思想
Spring 必背
- [ ] Bean 生命周期
- [ ] 循环依赖如何解决
- [ ] 自动装配原理
- [ ] 事务失效场景
MySQL 必背
- [ ] B+ 树特点
- [ ] 最左前缀原则
- [ ] MVCC 原理
- [ ] redo vs undo vs binlog
Redis 必背
- [ ] 5 种基础数据结构
- [ ] RDB vs AOF
- [ ] 缓存穿透/击穿/雪崩
- [ ] 持久化机制
最后提醒：面试不是背书，理解 + 实践才是王道。 每个知识点都要问自己：是什么？怎么用？为什么？
祝面试顺利！🎉