← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(面试题模拟)面试速记卡(考前30秒速看)练习题(自测)学习资料

L41 - Java核心面试模拟

本节目标(学完能回答的面试题)

本节通过30道高频面试题的模拟训练,覆盖JVM、并发、集合三大核心领域,掌握标准答题框架和追问链应对策略。

核心知识(面试题模拟)

答题框架(STAR变体)


1. 一句话结论(先给答案,不要铺垫太久)
2. 核心原理(2-3个要点)
3. 关键细节(数据结构/流程图/源码级别)
4. 实际应用/踩坑经验
5. 追问延伸准备

一、JVM篇(10题)

Q1: 说一下JVM的内存区域划分

标准答案:


JVM内存结构(线程共享 + 线程私有):

线程私有:
├── 程序计数器(PC):当前线程执行的字节码行号
├── 虚拟机栈(VM Stack):栈帧(Frame) → 局部变量表+操作数栈+动态链接+返回地址
├── 本地方法栈(Native Stack):为Native方法服务

线程共享:
├── 堆(Heap):对象实例+数组,GC主要区域
│   ├── 新生代(Young): Eden + Survivor0 + Survivor1
│   └── 老年代(Old)
└── 方法区(MetaSpace, JDK8+):类信息+常量+静态变量

追问链:堆和栈的区别? → 栈溢出怎么排查? → MetaSpace和永久代区别?

Q2: GC算法有哪些?CMS和G1的区别?

标准答案:


基础算法:
  标记-清除:碎片多
  标记-整理:无碎片,但移动对象开销大
  复制算法:无碎片,但空间利用率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频繁怎么排查?

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

标准答案:


类加载7个阶段:加载→验证→准备→解析→初始化→使用→卸载

双亲委派:
  自底向上检查是否已加载,自顶向下尝试加载
  AppClassLoader → ExtClassLoader → BootstrapClassLoader
  
  目的:保证核心类(如java.lang.Object)只被加载一次

打破双亲委派的场景:
  1. SPI机制(JDBC): 线程上下文类加载器
  2. Tomcat: 每个WebApp独立类加载器
  3. OSGi: 网状类加载

Q4: JVM调优参数有哪些?

标准答案:


# 堆大小
-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频繁怎么处理?

Q5: 对象的创建过程和内存布局

标准答案:


创建过程:
  1. 类加载检查(是否已加载)
  2. 分配内存(指针碰撞/空闲列表)
  3. 初始化零值(保证实例字段有默认值)
  4. 设置对象头(Mark Word + 类型指针)
  5. 执行<init>方法(构造函数)

内存布局:
  对象头: Mark Word(哈希/锁信息/GC分代年龄) + 类型指针
  实例数据: 各字段值
  对齐填充: 8字节对齐

对象访问定位:
  句柄:栈→句柄池→实例池/类池(两次访问,但移动对象只需改句柄)
  直接指针:栈→对象(一次访问,HotSpot默认)

二、并发篇(10题)

Q6: synchronized的锁升级过程

标准答案:


锁升级过程(JDK6+):

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

Mark Word结构变化:
  无锁:     [hashCode | age | 0 | 01]
  偏向锁:   [threadID | epoch | age | 1 | 01]
  轻量级锁: [指向栈中锁记录的指针 | 00]
  重量级锁: [指向Monitor的指针 | 10]

偏向锁:第一个线程访问,CAS记录threadID,之后无需CAS
轻量级锁:多线程交替访问,CAS竞争,失败自旋
重量级锁:竞争激烈,自旋失败,进入阻塞(用户态→内核态切换)

追问链:偏向锁什么场景下会撤销? → 锁消除和锁粗化是什么? → 和ReentrantLock区别?

Q7: AQS原理

标准答案:


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: 剩余计数

Q8: 线程池参数和执行流程

标准答案:


7大参数:
  corePoolSize    → 核心线程数
  maximumPoolSize → 最大线程数
  keepAliveTime   → 非核心线程空闲存活时间
  unit            → 时间单位
  workQueue       → 阻塞队列
  threadFactory   → 线程工厂
  handler         → 拒绝策略

执行流程:
  提交任务
    │
    ├── 核心线程未满 → 创建核心线程执行
    │
    ├── 核心线程满 → 任务放入队列
    │
    ├── 队列满 → 创建非核心线程(到maximumPoolSize)
    │
    └── 都满 → 拒绝策略
        ├── AbortPolicy: 抛异常(默认)
        ├── CallerRunsPolicy: 调用者线程执行
        ├── DiscardPolicy: 静默丢弃
        └── DiscardOldestPolicy: 丢弃队列头部

线程池大小设置:
  CPU密集型: core = CPU核数 + 1
  IO密集型:  core = CPU核数 × 2(或 CPU核数 / (1-阻塞系数))

追问链:为什么不建议用Executors创建线程池? → 线程池满了但系统还在提交任务怎么办?

Q9: ThreadLocal原理和内存泄漏

标准答案:


原理:
  每个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
  否则下一个复用该线程的任务会读到脏数据

Q10: volatile和CAS

标准答案:


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包装多字段

三、集合篇(10题)

Q11: HashMap原理

标准答案:


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线程安全替代?

Q12: ConcurrentHashMap原理

标准答案:


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)

Q13: ArrayList vs LinkedList

标准答案:


ArrayList: 动态数组
  随机访问O(1),头部插入删除O(n)
  扩容: 1.5倍,Arrays.copyOf
  默认容量10

LinkedList: 双向链表
  随机访问O(n),头尾操作O(1)
  无扩容开销
  实现了Deque接口

面试陷阱:
  "ArrayList增删慢"不完全对
  尾部增删也是O(1)(amortized)
  中间插入涉及arraycopy但不一定比链表慢(CPU缓存友好)

Q14: HashMap为什么不用AVL树而用红黑树

标准答案:


AVL树: 严格平衡(左右子树高度差<=1),查找O(logn)但旋转多
红黑树: 近似平衡(最长路径不超过最短2倍),查找略慢但增删旋转少

HashMap选择红黑树的原因:
  HashMap增删操作频繁,AVL的旋转开销大
  红黑树在增删和查找之间取得平衡
  实际hash冲突场景下两者性能差异不大
  但增删时红黑树的维护成本更低

评分标准


每个问题的评分维度:
┌────────┬───────────────────────────────────┐
│ 等级   │ 标准                               │
├────────┼───────────────────────────────────┤
│ A 优秀 │ 结论清晰+原理深入+源码细节+实战经验  │
│ B 良好 │ 结论正确+原理清晰+少量细节           │
│ C 合格 │ 能说出核心概念,但不深入              │
│ D 不合格│ 概念模糊或遗漏关键点                 │
└────────┴───────────────────────────────────┘

面试速记卡(考前30秒速看)

练习题(自测)

1. 完整口述一次synchronized锁升级的过程(限时2分钟)

2. 手写一个DCL单例模式,解释为什么用volatile

3. 画出AQS的CLH队列结构,解释park/unpark机制

4. 解释HashMap扩容时元素重新分配的优化(1.8 vs 1.7)

5. 如果面试官问"你遇到过什么JVM问题",你会怎么答?

学习资料