本节通过30道高频面试题的模拟训练,覆盖JVM、并发、集合三大核心领域,掌握标准答题框架和追问链应对策略。
1. 一句话结论(先给答案,不要铺垫太久)
2. 核心原理(2-3个要点)
3. 关键细节(数据结构/流程图/源码级别)
4. 实际应用/踩坑经验
5. 追问延伸准备
标准答案:
JVM内存结构(线程共享 + 线程私有):
线程私有:
├── 程序计数器(PC):当前线程执行的字节码行号
├── 虚拟机栈(VM Stack):栈帧(Frame) → 局部变量表+操作数栈+动态链接+返回地址
├── 本地方法栈(Native Stack):为Native方法服务
线程共享:
├── 堆(Heap):对象实例+数组,GC主要区域
│ ├── 新生代(Young): Eden + Survivor0 + Survivor1
│ └── 老年代(Old)
└── 方法区(MetaSpace, JDK8+):类信息+常量+静态变量
追问链:堆和栈的区别? → 栈溢出怎么排查? → MetaSpace和永久代区别?
标准答案:
基础算法:
标记-清除:碎片多
标记-整理:无碎片,但移动对象开销大
复制算法:无碎片,但空间利用率50%
分代收集:新生代用复制,老年代用标记-整理/清除
CMS (Concurrent Mark Sweep):
4个阶段:初始标记(STW) → 并发标记 → 重新标记(STW) → 并发清除
优点:停顿短 缺点:碎片多、CPU敏感、浮动垃圾
G1 (Garbage First):
Region化堆内存,优先回收垃圾最多的Region
Young GC + Mixed GC + Full GC
优点:可预测停顿时间、无碎片 缺点:内存占用多10-20%
JDK9+默认G1,JDK11+可用ZGC(亚毫秒停顿)
追问链:什么对象会进入老年代? → 大对象怎么处理? → Full GC频繁怎么排查?
标准答案:
类加载7个阶段:加载→验证→准备→解析→初始化→使用→卸载
双亲委派:
自底向上检查是否已加载,自顶向下尝试加载
AppClassLoader → ExtClassLoader → BootstrapClassLoader
目的:保证核心类(如java.lang.Object)只被加载一次
打破双亲委派的场景:
1. SPI机制(JDBC): 线程上下文类加载器
2. Tomcat: 每个WebApp独立类加载器
3. OSGi: 网状类加载
标准答案:
# 堆大小
-Xms2g -Xmx2g # 初始=最大,避免扩容抖动
-Xmn1g # 新生代大小
-XX:MetaspaceSize=256m # 元空间初始大小
# GC选择
-XX:+UseG1GC # 使用G1
-XX:MaxGCPauseMillis=200 # 目标最大停顿200ms
# GC日志
-XX:+PrintGCDetails
-Xloggc:/logs/gc.log
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/logs/
追问链:Xms和Xmx为什么要设一样大? → OOM怎么排查? → 线上GC频繁怎么处理?
标准答案:
创建过程:
1. 类加载检查(是否已加载)
2. 分配内存(指针碰撞/空闲列表)
3. 初始化零值(保证实例字段有默认值)
4. 设置对象头(Mark Word + 类型指针)
5. 执行<init>方法(构造函数)
内存布局:
对象头: Mark Word(哈希/锁信息/GC分代年龄) + 类型指针
实例数据: 各字段值
对齐填充: 8字节对齐
对象访问定位:
句柄:栈→句柄池→实例池/类池(两次访问,但移动对象只需改句柄)
直接指针:栈→对象(一次访问,HotSpot默认)
标准答案:
锁升级过程(JDK6+):
无锁 → 偏向锁 → 轻量级锁 → 重量级锁
Mark Word结构变化:
无锁: [hashCode | age | 0 | 01]
偏向锁: [threadID | epoch | age | 1 | 01]
轻量级锁: [指向栈中锁记录的指针 | 00]
重量级锁: [指向Monitor的指针 | 10]
偏向锁:第一个线程访问,CAS记录threadID,之后无需CAS
轻量级锁:多线程交替访问,CAS竞争,失败自旋
重量级锁:竞争激烈,自旋失败,进入阻塞(用户态→内核态切换)
追问链:偏向锁什么场景下会撤销? → 锁消除和锁粗化是什么? → 和ReentrantLock区别?
标准答案:
AQS (AbstractQueuedSynchronizer):
核心数据结构:
├── volatile int state # 同步状态
└── CLH双向队列(FIFO) # 等待线程队列
ReentrantLock加锁流程:
1. CAS尝试将state从0改为1
2. 成功 → 获取锁
3. 失败 → 进入CLH队列尾部排队
4. 前驱节点释放锁 → unpark当前线程
5. 公平锁:先到先得;非公平锁:新来线程可以先抢
state含义:
ReentrantLock: 0=未锁, 1=已锁, >1=重入次数
Semaphore: 剩余许可数
CountDownLatch: 剩余计数
标准答案:
7大参数:
corePoolSize → 核心线程数
maximumPoolSize → 最大线程数
keepAliveTime → 非核心线程空闲存活时间
unit → 时间单位
workQueue → 阻塞队列
threadFactory → 线程工厂
handler → 拒绝策略
执行流程:
提交任务
│
├── 核心线程未满 → 创建核心线程执行
│
├── 核心线程满 → 任务放入队列
│
├── 队列满 → 创建非核心线程(到maximumPoolSize)
│
└── 都满 → 拒绝策略
├── AbortPolicy: 抛异常(默认)
├── CallerRunsPolicy: 调用者线程执行
├── DiscardPolicy: 静默丢弃
└── DiscardOldestPolicy: 丢弃队列头部
线程池大小设置:
CPU密集型: core = CPU核数 + 1
IO密集型: core = CPU核数 × 2(或 CPU核数 / (1-阻塞系数))
追问链:为什么不建议用Executors创建线程池? → 线程池满了但系统还在提交任务怎么办?
标准答案:
原理:
每个Thread维护一个ThreadLocalMap
Key = ThreadLocal弱引用
Value = 存储的值(强引用)
内存泄漏原因:
ThreadLocal ref → WeakReference → ThreadLocal对象
Thread对象 → ThreadLocalMap → Entry[WeakReference(key), value]
ThreadLocal对象被GC回收后 → key=null,但value还在
如果线程不销毁(线程池),value永远无法回收
解决方案:
1. 用完必须remove()
2. ThreadLocal定义为private static final
注意:
在线程池中使用ThreadLocal,必须在finally中remove
否则下一个复用该线程的任务会读到脏数据
标准答案:
volatile两大作用:
1. 可见性: 写操作强制刷新到主内存,读操作从主内存加载
底层: storeload内存屏障
2. 禁止指令重排序
应用: DCL单例模式中防止对象初始化一半就被其他线程看到
volatile不保证原子性:
i++ 不是原子操作(读→改→写三步)
需要用AtomicInteger或synchronized
CAS (Compare And Swap):
原子操作: if(当前值==预期值) 更新为新值
底层: CPU指令 cmpxchg
Java: Unsafe类
CAS三大问题:
1. ABA问题 → AtomicStampedReference加版本号
2. 自旋开销 → 适应式自旋
3. 只能单变量 → AtomicReference包装多字段
标准答案:
JDK1.8: 数组 + 链表 + 红黑树
put流程:
1. hash(key) → 计算数组下标 (n-1) & hash
2. 数组位置为空 → 直接放入
3. 不为空 → key相同则覆盖,否则追加到链表尾部
4. 链表长度 >= 8 且数组长度 >= 64 → 树化为红黑树
5. 元素数量 > threshold → 扩容(2倍)
关键参数:
默认容量: 16(必须是2的幂)
负载因子: 0.75
树化阈值: 8
链化阈值: 6
最小树化容量: 64
扩容机制:
1.8优化:不需要重新计算hash
位置 = 原位置 或 原位置+旧容量
通过 (hash & oldCap) == 0 判断
追问链:为什么负载因子是0.75? → 红黑树为什么阈值是8? → HashMap线程安全替代?
标准答案:
JDK1.7: Segment分段锁(ReentrantLock)
16个Segment,每个Segment独立加锁
JDK1.8: CAS + synchronized
锁粒度:数组单个桶(bucket)
put流程:
1. 计算hash定位桶
2. 桶为空 → CAS写入
3. 桶不为空 → synchronized(头节点) → 遍历链表/红黑树
4. 正在扩容 → 协助迁移(helpTransfer)
size()方法:
baseCount + CounterCell数组(分散计数,类似LongAdder)
标准答案:
ArrayList: 动态数组
随机访问O(1),头部插入删除O(n)
扩容: 1.5倍,Arrays.copyOf
默认容量10
LinkedList: 双向链表
随机访问O(n),头尾操作O(1)
无扩容开销
实现了Deque接口
面试陷阱:
"ArrayList增删慢"不完全对
尾部增删也是O(1)(amortized)
中间插入涉及arraycopy但不一定比链表慢(CPU缓存友好)
标准答案:
AVL树: 严格平衡(左右子树高度差<=1),查找O(logn)但旋转多
红黑树: 近似平衡(最长路径不超过最短2倍),查找略慢但增删旋转少
HashMap选择红黑树的原因:
HashMap增删操作频繁,AVL的旋转开销大
红黑树在增删和查找之间取得平衡
实际hash冲突场景下两者性能差异不大
但增删时红黑树的维护成本更低
每个问题的评分维度:
┌────────┬───────────────────────────────────┐
│ 等级 │ 标准 │
├────────┼───────────────────────────────────┤
│ A 优秀 │ 结论清晰+原理深入+源码细节+实战经验 │
│ B 良好 │ 结论正确+原理清晰+少量细节 │
│ C 合格 │ 能说出核心概念,但不深入 │
│ D 不合格│ 概念模糊或遗漏关键点 │
└────────┴───────────────────────────────────┘
1. 完整口述一次synchronized锁升级的过程(限时2分钟)
2. 手写一个DCL单例模式,解释为什么用volatile
3. 画出AQS的CLH队列结构,解释park/unpark机制
4. 解释HashMap扩容时元素重新分配的优化(1.8 vs 1.7)
5. 如果面试官问"你遇到过什么JVM问题",你会怎么答?