← 返回首页 📚 实战课程
📑 本篇章节导航 (共21章,点击直达)
Q01:synchronized 和 ReentrantLock 的区别?Q02:HashMap 和 ConcurrentHashMap 的区别?Q03:线程池的核心参数有哪些?如何合理配置?Q04:volatile 和 synchronized 的区别?Q05:JVM 垃圾回收算法和常见收集器?Q06:AQS 的实现原理?Q07:HashMap 扩容(resize)过程?Q08:Java 8 和 Java 17 各有什么重要特性?Q09:CompletableFuture 的使用和原理?Q10:ThreadPoolExecutor 的生命周期状态有哪些?Q11:CAS 是什么?ABA 问题怎么解决?Q12:Java 内存模型的 happens-before 规则?Q13:G1 和 ZGC 的区别?Q14:线上 OOM 如何排查?Q15:类加载机制和双亲委派模型?Q16:Java 泛型擦除是什么?有什么影响?Q17:ThreadLocal 内存泄漏的原因和解决方案?Q18:锁粗化和锁消除是什么?Q19:Java 虚拟线程(Virtual Threads)了解吗?Q20:Java 17 的 sealed class 和 record 有什么实际应用?复习清单

Java核心面试20问

面向 5 年经验 Java 开发者,目标岗位 18-22K AI+Java 方向。
每题包含:标准回答 → 追问 → 追问回答 → 面试Tips。

Q01:synchronized 和 ReentrantLock 的区别?

标准回答:

synchronized 是 JVM 层面的关键字,通过 monitorenter/monitorexit 字节码指令实现,支持自动加锁释放;ReentrantLock 是 JDK 层面的 API,基于 AQS 实现,提供可中断、超时、公平锁、多条件变量等高级特性。性能上,JDK 6 之后 synchronized 经过锁升级优化(偏向锁→轻量级锁→重量级锁),两者在低竞争场景差异不大。

追问:synchronized 的锁升级过程是怎样的?

回答:

无锁 → 偏向锁(线程 ID 写入 Mark Word)→ 轻量级锁(CAS 自旋)→ 重量级锁(操作系统互斥量)。偏向锁在竞争时撤销,轻量级锁自旋失败后膨胀为重量级锁。批量重偏向和批量撤销是两个重要的优化阈值(默认 20 次和 40 次)。

Tips: 面试官常追问锁升级细节,建议手画 Mark Word 结构图。提到 JDK 15 默认关闭偏向锁是加分项。


Q02:HashMap 和 ConcurrentHashMap 的区别?

标准回答:

HashMap 线程不安全,允许 null key 和 null value;ConcurrentHashMap 线程安全,不允许 null。JDK 8 的 CHM 摒弃了 Segment 分段锁,改用 CAS + synchronized(锁数组头节点),锁粒度从段级别降到桶级别,并发度大幅提升。两者底层都是数组 + 链表 + 红黑树。

追问:CHM 的 put 流程中,哪些地方用了 CAS,哪些地方用了 synchronized?

回答:

初始化数组用 CAS(sizeCtl 控制);定位到空桶时用 CAS 插入新节点(tabAt + compareAndSwapInt);桶非空时 synchronized 锁住头节点再遍历插入/更新;扩容用 CAS + transferIndex 协调多线程迁移。设计思路是:乐观场景走 CAS 快路径,冲突场景退化为悲观锁。

Tips: 能说清 "CAS 用于空桶、synchronized 用于非空桶" 就够了,不要背源码。


Q03:线程池的核心参数有哪些?如何合理配置?

标准回答:

七大核心参数:corePoolSize(核心线程数)、maximumPoolSize(最大线程数)、keepAliveTime(非核心线程空闲存活时间)、unit(时间单位)、workQueue(阻塞队列)、threadFactory(线程工厂)、handler(拒绝策略)。配置原则:CPU 密集型设为 CPU 核心数 +1,IO 密集型设为 CPU 核心数 × 2 或根据 CPU 利用率公式 N_threads = N_cpu × (1 + W/C) 计算。

追问:四种拒绝策略分别是什么?生产环境推荐哪种?

回答:

AbortPolicy(抛异常,默认)、CallerRunsPolicy(由提交线程执行)、DiscardPolicy(静默丢弃)、DiscardOldestPolicy(丢弃队列最老任务)。生产推荐 CallerRunsPolicy 或自定义策略(记录日志 + 持久化到 DB/MQ 后异步重试),不推荐静默丢弃。


ThreadPoolExecutor executor = new ThreadPoolExecutor(
    8, 32, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1024),
    new ThreadFactoryBuilder().setNameFormat("biz-pool-%d").build(),
    (r, e) -> {
        log.warn("任务被拒绝: {}", r);
        // 持久化到 Redis/DB,后续补偿执行
    }
);

Tips: 一定不要用 Executors.newFixedThreadPool(),面试官会追问为什么(无界队列 OOM 风险)。


Q04:volatile 和 synchronized 的区别?

标准回答:

volatile 保证可见性(修改后立即刷新主内存)和有序性(禁止指令重排),但不保证原子性;synchronized 保证可见性、有序性和原子性。volatile 本质是通过内存屏障实现的,写操作前插入 StoreStore 屏障,读操作后插入 LoadLoad 屏障。

追问:volatile 能保证 i++ 的线程安全吗?为什么?

回答:

不能。i++ 不是原子操作(读取→加1→写回),volatile 只保证读到最新值,但两个线程可能同时读到相同值再各自 +1 写回,结果丢失一次更新。解决方案:AtomicInteger(CAS)、synchronized 或 LongAdder(分段累加,高并发更优)。


// LongAdder 比 AtomicInteger 高并发性能更好
LongAdder counter = new LongAdder();
counter.add(1);
long sum = counter.sum();

Tips: 能提到 LongAdder 的分段 CAS 思路(Cell 数组)是加分项。


Q05:JVM 垃圾回收算法和常见收集器?

标准回答:

四种基础算法:标记-清除(碎片问题)、标记-整理(移动开销)、复制(空间浪费)、分代收集。常见收集器:CMS(低延迟,已废弃)、G1(Region 化,可预测停顿)、ZGC(着色指针,亚毫秒停顿)、Parallel Scavenge(吞吐优先)。JDK 8 默认 Parallel + ParOld,JDK 9+ 默认 G1。

追问:G1 的 Mixed GC 触发条件和回收流程?

回答:

当老年代占用达到 IHOP 阈值(InitiatingHeapOccupancyPercent,默认 45%)时触发。流程:并发标记 → 最终标记 → 筛选回收(选择回收价值高的 Region)。G1 可通过 -XX:MaxGCPauseMillis 设定目标停顿时间,收集器据此选择回收哪些 Region。

Tips: 提到 ZGC 的着色指针(Colored Pointers)和读屏障(Load Barrier)是加分亮点。


Q06:AQS 的实现原理?

标准回答:

AQS(AbstractQueuedSynchronizer)是并发锁的底层框架,核心是一个 volatile int state + CLH 双向等待队列。独占模式(如 ReentrantLock)通过 tryAcquire/tryRelease 操作 state,共享模式(如 Semaphore)通过 tryAcquireShared/tryReleaseShared 操作 state。获取失败时线程封装为 Node 入队,通过 LockSupport.park/unpark 挂起和唤醒。

追问:AQS 的公平锁和非公平锁实现有什么区别?

回答:

非公平锁在 lock() 时先直接 CAS 尝试获取 state(可能插队),失败后再走 acquire() 入队流程;公平锁在 tryAcquire() 中先检查 hasQueuedPredecessors(),队列有前驱节点则直接返回 false 不抢锁。非公平吞吐更高但可能导致饥饿。


// 非公平锁的 lock() —— 先尝试插队
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

// 公平锁的 tryAcquire() —— 先检查队列
protected final boolean tryAcquire(int acquires) {
    if (c == 0) {
        if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
    }
    // ...
}

Tips: 能手画 CLH 队列结构(prev/next/nextWaiter/status)会加分。


Q07:HashMap 扩容(resize)过程?

标准回答:

当元素数量超过 threshold(capacity × loadFactor,默认 16 × 0.75 = 12)时触发扩容。JDK 8 创建新数组(容量翻倍),遍历旧数组每个桶:单节点直接重新 hash 定位;链表拆成高位链和低位链(通过 hash & oldCap == 0 判断);红黑树拆分,节点数 ≤ 6 时退化为链表。

追问:为什么多线程扩容会导致死循环?JDK 8 修复了吗?

回答:

JDK 7 使用头插法,多线程扩容时链表会反转,形成环形链表导致死循环。JDK 8 改用尾插法 + 高低位拆分,不会反转链表,解决了死循环问题。但 HashMap 仍然不是线程安全的(数据覆盖、size 不准确等问题仍存在)。

Tips: 能说出 "高低位拆分用 hash & oldCap 判断" 就是区分度。


Q08:Java 8 和 Java 17 各有什么重要特性?

标准回答:

Java 8:Lambda 表达式、Stream API、Optional、函数式接口、方法引用、CompletableFuture、新日期 API(java.time)、默认方法。Java 17(LTS):密封类(sealed classes)、模式匹配 instanceof、文本块、switch 表达式、记录类(record)、伪随机数生成器增强。Spring Boot 3.x 要求最低 Java 17。

追问:sealed class 和 final 有什么区别?

回答:

final 类不能被任何类继承;sealed class 通过 permits 关键字显式指定允许继承的子类,子类必须是 final、sealed 或 non-sealed 的。sealed 比-final 更灵活,允许受限的继承层次,配合模式匹配 switch 使用更优雅。


public sealed interface Shape permits Circle, Rectangle, Triangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}
public record Triangle(double a, double b, double c) implements Shape {}

// 模式匹配 switch
double area = switch (shape) {
    case Circle(var r) -> Math.PI * r * r;
    case Rectangle(var w, var h) -> w * h;
    case Triangle(var a, var b, var c) -> {
        double s = (a + b + c) / 2;
        yield Math.sqrt(s * (s-a) * (s-b) * (s-c));
    }
};

Tips: 提到 Spring Boot 3 必须 Java 17 说明你关注版本关系。


Q09:CompletableFuture 的使用和原理?

标准回答:

CompletableFuture 是 Java 8 引入的异步编程工具,实现了 Future 和 CompletionStage 接口。支持链式调用(thenApply/thenAccept)、组合(thenCombine/allOf/anyOf)、异常处理(exceptionally/handle)。底层基于 ForkJoinPool 或指定线程池执行,通过栈(Completion 链)管理回调。

追问:thenApply 和 thenCompose 的区别?

回答:

thenApply 类似 map,接收 Function<T, U>,返回 CompletableFuture<U>;thenCompose 类似 flatMap,接收 Function<T, CompletableFuture<U>>,返回 CompletableFuture<U>(自动展平)。whenComplete 不改变结果类型只做副作用。链式调用时 thenCompose 更适合组合多个异步步骤。


CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> getUserId())
    .thenCompose(id -> getUserInfo(id))  // 返回 CF,自动展平
    .thenApply(user -> user.getName())
    .exceptionally(ex -> "default");

Tips: 别忘了提线程池指定,默认 ForkJoinPool 在 IO 密集时可能不够用。


Q10:ThreadPoolExecutor 的生命周期状态有哪些?

标准回答:

五种状态:RUNNING(接收新任务并处理队列任务)、SHUTDOWN(不接收新任务但处理队列任务,调用 shutdown())、STOP(不接收不处理并中断进行中任务,调用 shutdownNow())、TIDYING(所有任务终止,workerCount=0)、TERMINATED(terminated() 方法执行完成)。状态存储在 ctl 高 3 位。

追问:shutdown() 和 shutdownNow() 的区别?

回答:

shutdown() 平滑关闭:拒绝新任务,等待已提交任务和队列任务完成;shutdownNow() 强制关闭:拒绝新任务、中断正在执行的任务、返回队列中未执行的任务列表。生产中推荐先 shutdown(),再 awaitTermination(timeout) 等待,超时后 shutdownNow()。


executor.shutdown();
if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
    executor.shutdownNow();
    log.warn("线程池未在 30s 内优雅关闭,已强制终止");
}

Tips: 能写出优雅关闭的代码模板是加分项。


Q11:CAS 是什么?ABA 问题怎么解决?

标准回答:

CAS(Compare And Swap)是无锁并发的核心操作:比较内存值与预期值,相等则更新为新值,整个过程原子性由 CPU 指令保证(x86 的 CMPXCHG)。ABA 问题是值从 A→B→A 变回原值,CAS 认为没变过。解决方案:AtomicStampedReference(加版本号)或 AtomicMarkableReference(加布尔标记)。

追问:Unsafe 类的 compareAndSwapInt 是如何保证原子性的?

回答:

底层调用 C++ 的 Atomic::cmpxchg,在 x86 架构上对应 LOCK CMPXCHG 指令,LOCK 前缀锁总线(或使用缓存一致性协议 MESI),确保多核下该指令的原子性。JDK 9+ 用 VarHandle 替代了部分 Unsafe 操作。

Tips: 提到 LOCK 前缀和 MESI 协议说明你理解硬件层面。


Q12:Java 内存模型的 happens-before 规则?

标准回答:

happens-before 是 JMM 定义的偏序关系,如果 A happens-before B,则 A 的操作结果对 B 可见。核心规则:程序顺序规则、volatile 写先于 volatile 读、synchronized 解锁先于后续加锁、线程 start() 先于其 run() 内容、线程 join() 返回先于后续操作、传递性规则。

追问:volatile 如何利用 happens-before 保证可见性?

回答:

volatile 写操作 happens-before 后续对同一变量的 volatile 读。JMM 通过内存屏障实现:volatile 写前插入 StoreStore 屏障(确保前面的写完成),写后插入 StoreLoad 屏障(确保写对其他线程可见);volatile 读后插入 LoadLoad 和 LoadStore 屏障。这保证了写操作的可见性传播。

Tips: happens-before 不是时间上的先后,而是可见性保证,这个区分很重要。


Q13:G1 和 ZGC 的区别?

标准回答:

G1 把堆划分为等大 Region(1-32MB),支持 Mixed GC 回收老年代和新生代,通过 -XX:MaxGCPauseMillis 控制目标停顿。ZGC(JDK 15+ 生产可用)也用 Region 但是动态大小的,通过着色指针(Color Pointers)+ 读屏障(Load Barrier)实现并发整理,停顿时间 < 1ms 且不随堆大小增长。

追问:ZGC 的读屏障是如何工作的?

回答:

对象引用加载时检查指针的 marked 位,如果颜色不对说明对象正在被移动,读屏障会自动修正指针(自愈)并指向新地址。这样 GC 移动对象时不需要 STW 来修正引用,应用线程自己做。代价是每次对象引用读取都多一次判断(约 4% 吞吐下降)。

Tips: 提到 "着色指针" 和 "读屏障自愈" 两个关键词就够了。


Q14:线上 OOM 如何排查?

标准回答:

三步走:(1) 保留现场:-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/dump.hprof 自动导出堆快照;(2) 分析 dump:用 MAT 或 VisualVM 找到支配树中最大的对象、GC Roots 引用链;(3) 定位代码:结合 Shallow Heap vs Retained Heap 区分大对象本身和它引用的对象总量。常见原因:内存泄漏(ThreadLocal 未清理、静态集合持续增长)、大对象分配(大文件一次性读入)。

追问:如何区分内存泄漏和内存溢出?

回答:

内存溢出是确实需要这么多内存但堆不够,加内存或优化数据结构可解决;内存泄漏是对象不再使用但 GC 无法回收(仍被 GC Roots 引用),加内存只是延缓。排查方法:多次 dump 对比,看某类对象数量持续增长且不回落就是泄漏。用 jmap -histo:live 触发 Full GC 后对比效果更明显。


# 排查命令链
jmap -histo:live <pid> | head -20     # GC后对象统计
jmap -dump:format=b,file=dump.hprof <pid>  # 导出堆dump
jstat -gcutil <pid> 1000 10           # GC趋势观察

Tips: 能说清 "泄漏 vs 溢出" 的区别和排查手段,面试官会认可。


Q15:类加载机制和双亲委派模型?

标准回答:

类加载五个阶段:加载(找 class 文件)→ 链接(验证、准备、分配默认值)→ 初始化(clinit)。双亲委派:加载器先委托父加载器加载,父加载器找不到再自己加载。保证核心类(如 java.lang.Object)不会被自定义类覆盖。打破双亲委派的场景:SPI(JDBC 用线程上下文类加载器)、Tomcat(每个 WebApp 独立类加载器)、OSGi(网状委托)。

追问:Tomcat 是如何打破双亲委派的?

回答:

Tomcat 的 WebAppClassLoader 先自己加载 WEB-INF/classes 和 WEB-INF/lib 下的类(不走双亲委派),加载不到再委托父加载器。这样不同 Web 应用可以使用同一库的不同版本互不干扰。但核心类(java. 开头)仍然走双亲委派保证安全。

Tips: 能举 SPI 和 Tomcat 两个打破双亲委派的例子足够了。


Q16:Java 泛型擦除是什么?有什么影响?

标准回答:

Java 泛型在编译时进行类型检查,编译后擦除为原始类型(Raw Type),运行时不存在泛型信息。擦除规则:无界擦除为 Object,有界擦除为上界类型。影响:不能 new T()、不能 instanceOf 泛型、不能创建泛型数组。桥方法(Bridge Method)由编译器生成保证多态正确性。

追问:泛型擦除后,运行时还能获取泛型信息吗?

回答:

可以通过反射部分获取:类继承上的泛型信息(getGenericSuperclass / getGenericInterfaces)保留在 Class 文件的 Signature 属性中。Spring 的 ResolvableType、Jackson 的 TypeReference 就是利用这个原理。但局部变量的泛型信息编译后确实丢失。


// 通过匿名子类保留泛型信息
TypeReference<List<String>> type = new TypeReference<>() {};
// type.getType() 运行时仍可获取 List<String>

Tips: 提到 TypeReference 和 Spring 的 ResolvableType 说明实战经验。


Q17:ThreadLocal 内存泄漏的原因和解决方案?

标准回答:

ThreadLocalMap 的 Entry 继承 WeakReference<ThreadLocal<?>>,Key 是弱引用会被 GC 回收,但 Value 是强引用。Key 被 GC 后 Value 仍存在,无法被访问也无法被回收(除非线程结束)。线程池场景线程复用,泄漏更严重。解决方案:使用后必须调用 remove(),最好放在 finally 块中。

追问:为什么 Key 设计为弱引用而不是强引用?

回答:

如果 Key 是强引用,即使 ThreadLocal 对象设为 null,Entry 仍然持有它和 Value,两者都无法回收,泄漏更严重。弱引用至少保证 ThreadLocal 对象可以被 GC,然后 Entry 的 Key 变 null。ThreadLocalMap 在 get/set/remove 时会顺带清理 Key 为 null 的 Entry(expungeStaleEntry),但不是及时的,所以必须手动 remove。


// 正确用法
ThreadLocal<Connection> connHolder = new ThreadLocal<>();
try {
    connHolder.set(getConnection());
    // 业务逻辑
} finally {
    connHolder.remove(); // 必须!
}

Tips: 强调 "线程池场景必须 remove()" 是一线经验。


Q18:锁粗化和锁消除是什么?

标准回答:

锁粗化(Lock Coarsening):JIT 检测到同一对象连续加锁/解锁,将多次锁操作合并为一次,减少锁开销。锁消除(Lock Elimination):JIT 通过逃逸分析发现锁对象不会逃出方法(不可能被其他线程访问),直接消除锁操作。两者都是 JIT 编译器的自动优化。

追问:逃逸分析还能做哪些优化?

回答:

除了锁消除,逃逸分析还支持:栈上分配(对象不逃出方法则在栈上分配,无需 GC)、标量替换(将对象拆解为基本类型成员直接在栈上使用)。通过 -XX:+DoEscapeAnalysis 开启(默认开启),-XX:+PrintEscapeAnalysis 可查看分析结果。


// 锁消除示例:StringBuffer 不逃出方法
public String concat(String a, String b) {
    StringBuffer sb = new StringBuffer(); // 不逃出
    sb.append(a);
    sb.append(b); // JIT 消除这两次 synchronized
    return sb.toString();
}

Tips: 锁粗化/锁消除是 JIT 优化,非 JVM 字节码层面,注意说清楚。


Q19:Java 虚拟线程(Virtual Threads)了解吗?

标准回答:

虚拟线程是 JDK 21 正式引入的轻量级线程,由 JVM 而非 OS 管理,创建和调度开销极小(可创建百万级)。底层是用户态的 Fiber,挂起时释放载体线程(Platform Thread),恢复时可能换一个载体线程。适合 IO 密集型场景(如大量 HTTP 调用、数据库查询),大幅提升吞吐量。使用 Executors.newVirtualThreadPerTaskExecutor() 创建。

追问:虚拟线程和协程(Kotlin Coroutines)的区别?

回答:

虚拟线程是 JVM 级别的 M:N 调度(M 个虚拟线程映射到 N 个平台线程),对现有代码几乎透明,不需要 async/await 语法;Kotlin 协程是语言级别的实现,需要 suspend 函数和协程作用域。虚拟线程的优势是与现有阻塞式 API 天然兼容,无需改造代码;劣势是当前不支持 finalizer、不推荐使用 synchronized(会 pin 住载体线程),建议用 ReentrantLock 替代。


// 虚拟线程示例
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
} // 10万并发,只需少量平台线程

Tips: 提到 "synchronized 会 pin 住载体线程" 说明你了解实际限制。


Q20:Java 17 的 sealed class 和 record 有什么实际应用?

标准回答:

record 是不可变数据载体类,自动生成 constructor/getter/equals/hashCode/toString,适合做 DTO、Value Object。sealed class 限制继承层次,配合 record 和模式匹配实现代数数据类型(ADT),使类型安全的 exhaustive switch 成为可能。Spring Framework 6 已支持 sealed class 作为配置类。

追问:record 能实现接口吗?能定义实例字段吗?

回答:

record 可以实现接口,但不能继承类(隐式继承 java.lang.Record)。不能定义实例字段(只有组件对应的 private final 字段),但可以定义静态字段和静态方法。可以在 compact constructor 中添加校验逻辑。


// record + sealed 实现类型安全的返回值
public sealed interface Result<T> {
    record Success<T>(T data) implements Result<T> {}
    record Failure<T>(String code, String msg) implements Result<T> {}
}

// 模式匹配
Result<Order> result = process(order);
switch (result) {
    case Success(var data) -> log.info("成功: {}", data);
    case Failure(var code, var msg) -> log.error("失败: {} - {}", code, msg);
    // 编译器检查穷举性,无需 default
}

Tips: 用 sealed + record + pattern matching 三件套举例最有说服力。


复习清单

考察方向题号核心关键词
锁机制Q01, Q04, Q18锁升级、volatile、JIT优化
并发容器Q02, Q07CHM、resize、高低位拆分
线程池Q03, Q10七大参数、拒绝策略、生命周期
JUC框架Q06, Q11, Q12AQS、CAS、happens-before
GCQ05, Q13G1 Mixed GC、ZGC着色指针
JVM诊断Q14, Q15OOM排查、双亲委派
类型系统Q16, Q17, Q20泛型擦除、ThreadLocal、sealed
新特性Q08, Q09, Q19CompletableFuture、虚拟线程、record