--- url: /java/Java面试知识点串联指南.md --- # Java 面试知识点串联指南 > **核心理念**：用"从代码到架构"的纵向主线，把分散的知识点串成网 *** ## 📌 一、核心串联主线 ### **五层递进模型** ``` ┌─────────────────────────────────────────┐ │ 5. 架构层：微服务、缓存、消息队列 │ ├─────────────────────────────────────────┤ │ 4. 框架层：Spring、MyBatis、SpringBoot │ ├─────────────────────────────────────────┤ │ 3. 并发层：锁、线程池、JUC │ ├─────────────────────────────────────────┤ │ 2. JVM 层：内存模型、GC、类加载 │ ├─────────────────────────────────────────┤ │ 1. 基础层：集合、IO、反射、泛型 │ └─────────────────────────────────────────┘ ``` **串联方法**：从一行代码出发，逐层深入 ```java // 从一个简单的 HashMap 出发 Map 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 * \[ ] 缓存穿透/击穿/雪崩 * \[ ] 持久化机制 *** > **最后提醒**：面试不是背书，理解 + 实践才是王道。 > 每个知识点都要问自己：**是什么？怎么用？为什么？** > > 祝面试顺利！🎉