
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
Generated by kimi-k2.6 model
面向 Senior/Staff 级别 Java 开发岗位的系统性面试准备文档。涵盖 JVM、并发、Spring、GC 等核心知识点,深度解析原理 + 实战 + 源码。
目录
- Java 核心基础
- JMM(Java 内存模型)
- volatile 关键字
- synchronized 原理
- AQS & Lock
- 线程池原理
- 并发容器
- GC 算法
- JVM 调优
- Spring 核心
- 设计模式
- FAQ
1. Java 核心基础
1.1 概念定义
Java 是一门面向对象、静态类型、编译型的编程语言。核心特性包括:
- Write Once, Run Anywhere:字节码 + JVM 实现跨平台
- 自动内存管理:GC 自动回收,开发者无需手动释放
- 强类型系统:编译时类型检查,减少运行时错误
1.2 HashMap 底层原理
// HashMap 底层结构:数组 + 链表/红黑树
// JDK 1.8 之前:数组 + 链表
// JDK 1.8 之后:数组 + 链表(长度 > 8 转红黑树)
public class HashMap<K, V> extends AbstractMap<K, V>
implements Map<K, V>, Cloneable, Serializable {
// 默认初始容量 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 默认负载因子 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转红黑树阈值
static final int TREEIFY_THRESHOLD = 8;
// 底层数组
transient Node<K, V>[] table;
}put 流程:
1. 计算 key 的 hash 值
2. (n - 1) & hash 定位数组下标
3. 如果该位置为空,直接插入
4. 如果该位置有值,遍历链表/红黑树
- key 相同,覆盖 value
- key 不同,插入链表尾部
5. 检查是否需要扩容(size > threshold = capacity * loadFactor)
面试追问:为什么容量是 2 的幂次方?
因为
hash % n可以优化为(n - 1) & hash,位运算比取模快。
1.3 ArrayList vs LinkedList
| 维度 | ArrayList | LinkedList |
|---|---|---|
| 底层结构 | 动态数组 | 双向链表 |
| 随机访问 | O(1) | O(n) |
| 尾部插入 | O(1)(均摊) | O(1) |
| 头部插入 | O(n) | O(1) |
| 内存占用 | 少(只存数据) | 多(额外指针) |
| 适用场景 | 读多写少 | 频繁插入删除 |
项目代码示例:
// 读多写少:用 ArrayList
List<User> users = new ArrayList<>();
users.addAll(userService.findAll());
// 频繁插入删除:用 LinkedList
Deque<Task> taskQueue = new LinkedList<>();
taskQueue.addFirst(new Task());
taskQueue.removeLast();1.4 泛型原理(类型擦除)
// 编译前
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);
// 编译后(类型擦除)
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 自动插入强制转换为什么需要类型擦除?
为了向后兼容。Java 5 引入泛型时,已有的非泛型代码需要能继续使用。
注意事项:
// ❌ 不能用基本类型
List<int> list; // 编译错误
// ✅ 用包装类
List<Integer> list; // 正确
// ❌ 不能创建泛型数组
T[] array = new T[10]; // 编译错误
// ✅ 用 Object 数组 + 强制转换
Object[] array = new Object[10];
T item = (T) array[0];2. JMM(Java 内存模型)
2.1 概念定义
JMM(Java Memory Model)定义了 Java 程序中各种变量(线程共享变量)的访问规则,以及在 JVM 中将变量存储到内存和从内存中读取变量这样的底层细节。
┌─────────────────────────────────────────────────────┐
│ JMM 内存模型 │
├─────────────────────────────────────────────────────┤
│ │
│ Thread A Main Memory Thread B │
│ ┌─────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Working │ │ │ │ Working │ │
│ │ Memory │ ←──→ │ Heap │ ←──→ │ Memory │ │
│ │ (cache) │ │ │ │ (cache) │ │
│ └─────────┘ └──────────┘ └─────────┘ │
│ ↑ ↑ │
│ ┌─────────┐ ┌─────────┐ │
│ │ 本地内存 │ │ 本地内存 │ │
│ └─────────┘ └─────────┘ │
│ │
│ 问题:线程 A 修改变量后,线程 B 何时能看到? │
│ 答案:通过 happens-before 规则保证可见性 │
│ │
└─────────────────────────────────────────────────────┘
2.2 happens-before 规则
定义:如果操作 A happens-before 操作 B,那么 A 的结果对 B 可见。
8 条规则:
- 程序次序规则:同一个线程中,前面的操作 happens-before 后面的操作
- 监视器锁规则:unlock happens-before 后面对同一个锁的 lock
- volatile 规则:对 volatile 变量的写 happens-before 后面对该变量的读
- 传递性:A happens-before B,B happens-before C,则 A happens-before C
- 线程启动规则:Thread.start() happens-before 线程中的每个操作
- 线程终止规则:线程中的所有操作 happens-before 线程的终止检测
- 中断规则:对线程 interrupt() 调用 happens-before 被中断线程检测到中断事件
- 对象终结规则:构造函数执行 happens-before finalize() 方法
面试代码示例:
public class HappensBeforeDemo {
private int a = 0;
private volatile boolean flag = false;
public void writer() {
a = 42; // 1
flag = true; // 2:volatile 写
}
public void reader() {
if (flag) { // 3:volatile 读
System.out.println(a); // 4:保证看到 a = 42
}
}
}
// 分析:
// 1 happens-before 2(程序次序规则)
// 2 happens-before 3(volatile 规则)
// 3 happens-before 4(程序次序规则)
// 由传递性:1 happens-before 4,所以 reader 一定看到 a = 422.3 重排序
编译器重排序:编译器为了优化性能,可能会改变指令的执行顺序(不改变单线程语义)。
处理器重排序:现代 CPU 采用乱序执行(Out-of-Order Execution),指令可能不按程序顺序执行。
内存系统重排序:由于缓存的存在,写入操作可能延迟对其他处理器可见。
// 重排序导致的问题示例
public class ReorderingDemo {
int x = 0, y = 0;
int a = 0, b = 0;
public void thread1() {
x = 1; // 可能被重排序到后面
a = y;
}
public void thread2() {
y = 1; // 可能被重排序到后面
b = x;
}
// 可能出现 a = 0, b = 0 的结果(如果都发生了重排序)
}2.4 Java 对比表
| 维度 | Java JMM | Go 内存模型 | C++ 内存模型 |
|---|---|---|---|
| 可见性保证 | volatile/synchronized | channel/sync | atomic/memory_order |
| 重排序控制 | happens-before | happens-before | memory_order |
| 复杂性 | 中等 | 简单 | 复杂 |
| 学习曲线 | 陡峭 | 平缓 | 陡峭 |
2.5 业界案例
| 公司 | 场景 | 实践 |
|---|---|---|
| 阿里巴巴 | 高并发交易系统 | volatile + CAS 实现无锁队列 |
| 美团 | 订单状态同步 | volatile 保证状态可见性 |
| 实时推荐系统 | happens-before 保证数据一致性 |
2.6 FAQ
Q: JMM 和 JVM 内存结构有什么区别?
JMM 是抽象的内存模型规范,JVM 内存结构是具体的实现(堆、栈、方法区等)。JMM 定义了线程如何与主内存交互,JVM 内存结构定义了内存的物理布局。
Q: 为什么需要 JMM?
因为多核 CPU 有缓存一致性(MESI)协议,但不同 CPU 厂商实现不同。JMM 提供统一的编程接口,让开发者不用关心底层硬件细节。
3. volatile 关键字
3.1 概念定义
volatile 是 Java 中最轻量的同步机制,保证变量的可见性和禁止指令重排序。
public class VolatileDemo {
private volatile boolean flag = false;
public void shutdown() {
flag = true; // 写 volatile 变量
}
public void doWork() {
while (!flag) { // 读 volatile 变量
// 工作
}
System.out.println("Shutdown!");
}
}3.2 两个核心语义
1. 可见性:
Thread A 写入 volatile 变量 → 立即刷新到主内存
Thread B 读取 volatile 变量 → 立即从主内存读取
2. 禁止重排序:
对 volatile 变量的写操作,前面的代码不能重排序到后面
对 volatile 变量的读操作,后面的代码不能重排序到前面
内存屏障实现:
// volatile 写操作插入的内存屏障
storeStoreBarrier(); // 禁止前面的普通写重排序到后面
volatileWrite(); // volatile 写
storeLoadBarrier(); // 禁止后面的普通读写重排序到前面
// volatile 读操作插入的内存屏障
loadLoadBarrier(); // 禁止后面的普通读重排序到前面
volatileRead(); // volatile 读
loadStoreBarrier(); // 禁止后面的普通写重排序到前面3.3 不能保证原子性
public class VolatileNotAtomic {
private volatile int count = 0;
// ❌ 非原子操作
public void increment() {
count++; // 实际是分三步:读 → 修改 → 写
}
// ✅ 需要 synchronized 或 AtomicInteger
public synchronized void safeIncrement() {
count++;
}
}3.4 适用场景
// 1. 状态标志
private volatile boolean running = true;
public void shutdown() { running = false; }
// 2. 单例模式(双重检查锁定)
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
// 为什么需要 volatile?
// instance = new Singleton() 实际分三步:
// 1. 分配内存
// 2. 初始化对象
// 3. 赋值给引用
// 如果没有 volatile,2 和 3 可能重排序,导致其他线程拿到未初始化的对象3.5 面试误区
❌ 错误认知:
- "volatile 可以保证线程安全" → 不能保证原子性
- "volatile 比 synchronized 快,所以都用 volatile" → 场景不同
✅ 正确认知:
- volatile 只保证可见性和有序性
- 复合操作(i++)需要 synchronized 或 Atomic
3.6 FAQ
Q: volatile 和 synchronized 的区别?
| 维度 | volatile | synchronized |
|---|---|---|
| 可见性 | ✅ | ✅ |
| 原子性 | ❌ | ✅ |
| 有序性 | ✅ | ✅ |
| 阻塞 | 不会阻塞线程 | 会阻塞线程 |
| 适用场景 | 单一变量读写 | 复合操作 |
Q: volatile 在单核 CPU 上还有用吗?
有用。单核 CPU 虽然不存在缓存一致性问题,但编译器和 JVM 仍可能重排序指令。volatile 的禁止重排序语义仍然有效。
4. synchronized 原理
4.1 概念定义
synchronized 是 Java 内置的同步机制,可以修饰方法或代码块,保证原子性、可见性和有序性。
// 三种用法
public class SynchronizedDemo {
// 1. 修饰实例方法(锁当前对象)
public synchronized void method1() {}
// 2. 修饰静态方法(锁 Class 对象)
public static synchronized void method2() {}
// 3. 修饰代码块(锁指定对象)
public void method3() {
synchronized (this) {}
}
}4.2 锁升级过程
无锁 → 偏向锁 → 轻量级锁 → 重量级锁
1. 无锁:对象刚创建,没有线程竞争
2. 偏向锁:只有一个线程访问,Mark Word 记录线程 ID
3. 轻量级锁:有轻微竞争,线程自旋(CAS)获取锁
4. 重量级锁:竞争激烈,线程阻塞,等待操作系统调度
Mark Word 结构:
┌──────────────────────────────────────────────────────────┐
│ 对象头(Object Header) │
├──────────────────────────────────────────────────────────┤
│ Mark Word (64 bit) │
│ ┌──────────────┬──────────────┬──────────────────────┐ │
│ │ hashCode │ age (GC) │ biased_lock | lock │ │
│ │ (31 bit) │ (4 bit) │ (1 bit) │ (2 bit)│ │
│ └──────────────┴──────────────┴──────────────────────┘ │
│ │
│ lock 状态: │
│ 01 - 无锁/偏向锁 │
│ 00 - 轻量级锁 │
│ 10 - 重量级锁 │
│ 11 - GC 标记 │
└──────────────────────────────────────────────────────────┘
4.3 Monitor 原理
// synchronized 底层基于 Monitor(监视器锁)
// 每个 Java 对象关联一个 Monitor
// 等价代码:
synchronized (obj) {
// 代码块
}
// 编译后:
monitorenter // 获取 Monitor
// 代码块
monitorexit // 释放 MonitorMonitor 结构:
┌─────────────────────────────────────┐
│ ObjectMonitor │
├─────────────────────────────────────┤
│ _owner → 持有锁的线程 │
│ _EntryList → 阻塞等待锁的线程 │
│ _WaitSet → 调用 wait 的线程 │
│ _count → 重入次数 │
│ _recursions → 递归次数 │
└─────────────────────────────────────┘
4.4 锁优化
1. 偏向锁:
场景:只有一个线程访问同步块
优化:Mark Word 记录线程 ID,下次该线程进入无需 CAS
参数:-XX:+UseBiasedLocking(默认开启)
2. 轻量级锁:
场景:有轻微竞争,但竞争不激烈
优化:线程自旋(CAS)获取锁,不阻塞
参数:-XX:+UseSpinning(默认开启)
3. 锁消除:
// JIT 编译器优化:检测到不可能共享,消除锁
public void method() {
StringBuffer sb = new StringBuffer(); // 局部变量,不可能逃逸
sb.append("a"); // 锁被消除
}4. 锁粗化:
// 优化前:频繁加锁解锁
for (int i = 0; i < 100; i++) {
synchronized (this) {
doSomething();
}
}
// 优化后:扩大锁范围
synchronized (this) {
for (int i = 0; i < 100; i++) {
doSomething();
}
}4.5 业界案例
| 公司 | 场景 | 实践 |
|---|---|---|
| 阿里巴巴 | 高并发计数器 | synchronized + CAS 混合使用 |
| 美团 | 订单号生成 | synchronized 保证唯一性 |
| 字节跳动 | 配置中心更新 | synchronized 保证配置原子性 |
4.6 FAQ
Q: synchronized 和 ReentrantLock 的区别?
| 维度 | synchronized | ReentrantLock |
|---|---|---|
| 实现 | JVM 内置(Monitor) | AQS(Java 实现) |
| 等待可中断 | ❌ | ✅ |
| 公平锁 | ❌ | ✅ |
| 条件变量 | 1 个(wait/notify) | 多个(Condition) |
| 性能 | JDK 6+ 优化后接近 | 略高(更灵活) |
| 编码 | 简洁(自动释放) | 需要手动释放 |
Q: 为什么 JDK 6 之前 synchronized 性能差?
JDK 6 之前 synchronized 直接映射到操作系统互斥量(mutex),每次加锁都涉及用户态到内核态的切换,开销大。JDK 6 引入锁升级机制后,大多数情况下使用偏向锁或轻量级锁,避免内核态切换。
5. AQS & Lock
5.1 概念定义
AQS(AbstractQueuedSynchronizer)是 Java 并发包的核心框架,ReentrantLock、CountDownLatch、Semaphore 等都基于 AQS 实现。
// AQS 核心结构
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer {
// 同步状态(volatile)
private volatile int state;
// FIFO 队列头
private transient volatile Node head;
// FIFO 队列尾
private transient volatile Node tail;
}Node 结构:
static final class Node {
volatile int waitStatus; // 等待状态(SIGNAL/CANCELLED/CONDITION/PROPAGATE)
volatile Node prev; // 前驱节点
volatile Node next; // 后继节点
volatile Thread thread; // 绑定的线程
Node nextWaiter; // 共享/独占模式标记
}5.2 ReentrantLock 原理
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
// 独占锁实现
abstract static class Sync extends AbstractQueuedSynchronizer {
// 尝试获取锁
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
}获取锁流程:
1. CAS 尝试获取锁(state = 0 → 1)
2. 如果失败,检查是否是重入(当前线程已持有锁)
3. 如果不是重入,加入 AQS 队列尾部
4. 前驱节点释放锁时,唤醒当前节点
5. 当前节点被唤醒后,再次尝试获取锁
5.3 CountDownLatch
// 场景:主线程等待多个子线程完成
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
int n = 3;
CountDownLatch latch = new CountDownLatch(n);
for (int i = 0; i < n; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " done");
latch.countDown(); // 计数器减 1
}).start();
}
latch.await(); // 等待计数器为 0
System.out.println("All threads done!");
}
}对比:
| 工具 | 作用 | 场景 |
|---|---|---|
| CountDownLatch | 一个线程等待多个线程 | 启动加载、并行计算 |
| CyclicBarrier | 多个线程互相等待 | 分阶段任务 |
| Semaphore | 控制并发数量 | 限流、资源池 |
| Exchanger | 两个线程交换数据 | 数据校对 |
5.4 项目代码示例
// 连接池实现(基于 Semaphore)
public class ConnectionPool {
private final Semaphore semaphore;
private final BlockingQueue<Connection> pool;
public ConnectionPool(int maxConnections) {
this.semaphore = new Semaphore(maxConnections);
this.pool = new LinkedBlockingQueue<>();
// 初始化连接...
}
public Connection borrowConnection() throws InterruptedException {
semaphore.acquire(); // 获取许可
return pool.take();
}
public void returnConnection(Connection conn) {
pool.offer(conn);
semaphore.release(); // 释放许可
}
}5.5 FAQ
Q: AQS 为什么用双向链表而不是单向链表?
- 取消节点:需要修改前驱节点的 next 指针,双向链表 O(1)
- 判断前驱状态:需要向前遍历找到 SIGNAL 状态的节点
- 避免死锁:单向链表在并发修改时容易出问题
Q: ReentrantLock 公平锁和非公平锁的区别?
// 非公平锁(默认):新线程可能插队获取锁
// 公平锁:严格按照队列顺序获取锁
ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
// 非公平锁性能更高(减少线程切换)
// 公平锁避免饥饿问题6. 线程池原理
6.1 概念定义
线程池是管理线程的池化技术,避免频繁创建/销毁线程的开销,控制并发数量。
// 线程池核心参数
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数
int maximumPoolSize, // 最大线程数
long keepAliveTime, // 空闲线程存活时间
TimeUnit unit, // 时间单位
BlockingQueue<Runnable> workQueue, // 任务队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 拒绝策略
)6.2 执行流程
提交任务
│
├── 当前线程数 < corePoolSize?
│ ├── 是 → 创建新线程执行任务
│ └── 否 → 继续
│
├── 任务队列未满?
│ ├── 是 → 加入队列等待
│ └── 否 → 继续
│
├── 当前线程数 < maximumPoolSize?
│ ├── 是 → 创建新线程执行任务
│ └── 否 → 执行拒绝策略
拒绝策略:
| 策略 | 行为 |
|---|---|
| AbortPolicy | 直接抛出异常(默认) |
| CallerRunsPolicy | 由调用线程执行任务 |
| DiscardPolicy | 静默丢弃任务 |
| DiscardOldestPolicy | 丢弃最老的任务,重试提交 |
6.3 常用线程池(不推荐直接使用)
// ❌ 不推荐:有 OOM 风险
Executors.newFixedThreadPool(100); // 无界队列,可能 OOM
Executors.newCachedThreadPool(); // 允许创建无限线程
Executors.newSingleThreadExecutor(); // 无界队列
// ✅ 推荐:自定义线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
4, // 核心线程数
8, // 最大线程数
60, TimeUnit.SECONDS, // 空闲线程存活时间
new LinkedBlockingQueue<>(100), // 有界队列
new ThreadFactoryBuilder().setNameFormat("pool-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);6.4 线程池调优
// CPU 密集型任务:线程数 = CPU 核心数 + 1
int cpuCount = Runtime.getRuntime().availableProcessors();
ThreadPoolExecutor cpuExecutor = new ThreadPoolExecutor(
cpuCount, cpuCount + 1, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100)
);
// I/O 密集型任务:线程数 = CPU 核心数 * 2
ThreadPoolExecutor ioExecutor = new ThreadPoolExecutor(
cpuCount * 2, cpuCount * 4, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000)
);6.5 项目代码示例
// Spring 中的线程池配置
@Configuration
public class ThreadPoolConfig {
@Bean("taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setThreadNamePrefix("task-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
}
// 使用
@Service
public class AsyncService {
@Async("taskExecutor")
public void asyncTask() {
// 异步执行
}
}6.6 FAQ
Q: 线程池中的线程异常了会怎样?
线程池会捕获异常,创建新线程替代异常线程。但如果任务抛异常且未捕获,其他任务不受影响。
Q: 如何优雅关闭线程池?
// 1. 不再接受新任务
executor.shutdown();
// 2. 等待现有任务完成(带超时)
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
// 3. 强制关闭
executor.shutdownNow();
}7. 并发容器
7.1 ConcurrentHashMap
// JDK 1.7:Segment + HashEntry(分段锁)
// JDK 1.8:Node + CAS + synchronized(细粒度锁)
// JDK 1.8 结构
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
// 底层数组
transient volatile Node<K, V>[] table;
// 扩容时使用
private transient volatile Node<K, V>[] nextTable;
// 控制扩容的标识
private transient volatile int sizeCtl;
}put 流程(JDK 1.8):
1. 计算 hash,定位数组下标
2. 如果该位置为空,CAS 插入
3. 如果该位置有值:
- 如果是链表,synchronized 锁住头节点,遍历插入
- 如果是红黑树,按树规则插入
4. 检查是否需要扩容
与 HashTable 对比:
| 维度 | ConcurrentHashMap | HashTable | Collections.synchronizedMap |
|---|---|---|---|
| 锁粒度 | 分段/节点级 | 全局锁 | 全局锁 |
| 并发度 | 高(默认 16 段) | 低 | 低 |
| null 支持 | ❌ | ❌ | 取决于原 Map |
| 性能 | 高 | 低 | 低 |
7.2 CopyOnWriteArrayList
// 写时复制:读不加锁,写时复制新数组
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 底层数组(volatile)
private transient volatile Object[] array;
// 写操作:加锁,复制新数组
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements); // volatile 写,保证可见性
return true;
} finally {
lock.unlock();
}
}
}适用场景:
- 读多写少(读操作占 90% 以上)
- 数据量不大(复制数组有开销)
7.3 BlockingQueue
// 常用实现
ArrayBlockingQueue<integer> abq = new ArrayBlockingQueue<>(100); // 有界数组
LinkedBlockingQueue<integer> lbq = new LinkedBlockingQueue<>(100); // 有界链表
PriorityBlockingQueue<integer> pbq = new PriorityBlockingQueue<>(); // 优先级队列
DelayQueue<Delayed> dq = new DelayQueue<>(); // 延迟队列
// 核心方法
queue.put(item); // 队列满时阻塞
queue.take(); // 队列空时阻塞
queue.offer(item, timeout, unit); // 超时等待
queue.poll(timeout, unit); // 超时等待7.4 FAQ
Q: ConcurrentHashMap 为什么不允许 null key/value?
避免二义性:
map.get(key) == null无法区分是 key 不存在还是 value 为 null。在多线程环境下,这种二义性会导致问题。
Q: CopyOnWriteArrayList 的迭代器有什么特点?
迭代器是快照迭代器,创建时复制当前数组引用,后续修改不影响迭代。但可能读到旧数据。
8. GC 算法
8.1 概念定义
GC(Garbage Collection)是 Java 自动内存管理的核心机制,自动回收不再使用的对象。
┌─────────────────────────────────────────────────────┐
│ JVM 堆内存布局 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ 老年代(Old Gen) │ │
│ │ -XX:MaxHeapSize │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ Eden(伊甸园) │ │ Survivor 0 │ │
│ │ 新对象分配于此 │ │ (From) │ │
│ │ │ │ │ │
│ └─────────────────────┘ └─────────────────────┘ │
│ ┌─────────────────────┐ │
│ │ Survivor 1 │ │
│ │ (To) │ │
│ └─────────────────────┘ │
│ │
│ 新生代(Young Gen):Eden + Survivor 0 + Survivor 1 │
│ │
└─────────────────────────────────────────────────────┘
8.2 GC 算法对比
| 算法 | 特点 | 适用场景 | JDK 版本 |
|---|---|---|---|
| Serial | 单线程,STW | 单核/小内存 | 所有 |
| Parallel | 多线程,吞吐量优先 | 后台计算 | 所有 |
| CMS | 低延迟,并发标记 | 互联网应用 | JDK 8 及之前 |
| G1 | 区域化,可预测停顿 | 大堆内存 | JDK 9+ 默认 |
| ZGC | 超低延迟(< 10ms) | 超大堆 | JDK 11+ |
| Shenandoah | 超低延迟 | 超大堆 | JDK 12+ |
8.3 G1 GC 详解
G1(Garbage First)特点:
1. 将堆划分为多个 Region(1MB ~ 32MB)
2. 优先回收垃圾最多的 Region
3. 可预测的停顿时间模型
G1 回收过程:
1. 初始标记(Initial Mark):STW,标记 GC Roots
2. 并发标记(Concurrent Mark):并发遍历对象图
3. 最终标记(Remark):STW,处理 SATB 队列
4. 筛选回收(Cleanup):STW,复制存活对象
G1 参数调优:
# 目标停顿时间(默认 200ms)
-XX:MaxGCPauseMillis=200
# 堆 Region 大小
-XX:G1HeapRegionSize=16m
# 并发线程数
-XX:ConcGCThreads=48.4 CMS vs G1 对比
| 维度 | CMS | G1 |
|---|---|---|
| 设计目标 | 低延迟 | 可预测停顿 |
| 内存碎片 | 严重(标记-清除) | 轻微(标记-整理) |
| 内存占用 | 低 | 高(Remembered Set) |
| 大对象处理 | 进入老年代 | 专有 Humongous Region |
| JDK 版本 | JDK 14 已移除 | JDK 9+ 默认 |
8.5 业界案例
| 公司 | 场景 | 实践 |
|---|---|---|
| 阿里巴巴 | 双十一大促 | G1 GC + 动态调参 |
| 美团 | 外卖订单系统 | ZGC 超低延迟 |
| 实时推荐 | Shenandoah GC |
8.6 FAQ
Q: Full GC 和 Minor GC 的区别?
Minor GC:回收新生代(Eden + Survivor),频率高,停顿短。 Full GC:回收整个堆(新生代 + 老年代 + 元空间),频率低,停顿长。
Q: 什么情况下会触发 Full GC?
- 老年代空间不足
- 元空间(Metaspace)不足
- System.gc() 调用(建议禁用)
- CMS GC 失败(Concurrent Mode Failure)
9. JVM 调优
9.1 常用参数
# 堆内存设置
-Xms4g -Xmx4g # 初始/最大堆内存(建议设置相同,避免动态扩缩)
-Xmn2g # 新生代大小
-XX:MetaspaceSize=256m # 元空间初始大小
-XX:MaxMetaspaceSize=512m # 元空间最大大小
# GC 设置
-XX:+UseG1GC # 使用 G1
-XX:MaxGCPauseMillis=200 # 目标停顿时间
# 日志
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-Xloggc:/var/log/gc.log
# OOM 时生成堆转储
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/heapdump.hprof9.2 调优工具
# 1. jstat:监控 GC
jstat -gcutil <pid> 1000 # 每秒输出 GC 统计
# 2. jmap:生成堆转储
jmap -dump:format=b,file=heap.hprof <pid>
# 3. jstack:线程 dump
jstack <pid> > thread.dump
# 4. VisualVM / JProfiler:图形化分析9.3 调优案例
# 场景:高并发 Web 服务,4C8G 机器
# 问题:频繁 Full GC,响应时间长
# 优化前参数
-Xms2g -Xmx4g -XX:+UseParallelGC
# 优化后参数
-Xms4g -Xmx4g # 固定堆大小
-Xmn2g # 新生代占 50%
-XX:+UseG1GC # 使用 G1
-XX:MaxGCPauseMillis=100 # 目标停顿 100ms
-XX:+ParallelRefProcEnabled # 并行处理引用
# 效果:GC 停顿从 500ms 降低到 50ms9.4 FAQ
Q: 为什么要设置 Xms = Xmx?
避免 JVM 运行时动态扩缩堆内存,减少 GC 压力。启动时就分配好全部内存,性能更稳定。
Q: 如何判断 JVM 调优是否有效?
- GC 日志分析:停顿时间、频率
- 应用监控:响应时间 P99、吞吐量
- 资源监控:CPU、内存使用率
10. Spring 核心
10.1 IoC 原理
// IoC(控制反转):对象的创建和依赖注入由 Spring 容器管理
// 传统方式
Service service = new Service();
service.setDao(new Dao());
// Spring 方式
@Service
public class Service {
@Autowired
private Dao dao; // Spring 自动注入
}Bean 生命周期:
1. 实例化(new)
2. 属性赋值(populate)
3. Aware 接口回调(BeanNameAware、ApplicationContextAware)
4. BeanPostProcessor.postProcessBeforeInitialization
5. @PostConstruct / init-method
6. BeanPostProcessor.postProcessAfterInitialization
7. 使用
8. @PreDestroy / destroy-method
9. 销毁
10.2 AOP 原理
// AOP(面向切面编程):动态代理实现
// JDK 动态代理(目标类实现接口)
public class JdkProxy implements InvocationHandler {
private Object target;
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before");
Object result = method.invoke(target, args);
System.out.println("After");
return result;
}
}
// CGLIB 代理(目标类不实现接口)
public class CglibProxy implements MethodInterceptor {
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("Before");
Object result = proxy.invokeSuper(obj, args);
System.out.println("After");
return result;
}
}Spring AOP 选择:
- 目标类实现接口 → JDK 动态代理
- 目标类不实现接口 → CGLIB 代理
- 可强制使用 CGLIB:
@EnableAspectJAutoProxy(proxyTargetClass = true)
10.3 事务传播
@Transactional
public class OrderService {
@Autowired
private PaymentService paymentService;
// REQUIRED(默认):加入当前事务,没有则新建
@Transactional
public void createOrder() {
// ...
paymentService.pay(); // 加入同一个事务
}
// REQUIRES_NEW:挂起当前事务,新建独立事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void log() {
// 独立事务,不受外部事务影响
}
// NESTED:嵌套事务(savepoint)
@Transactional(propagation = Propagation.NESTED)
public void subTask() {
// 可以独立回滚
}
}传播行为对比:
| 传播行为 | 外部有事务 | 外部无事务 |
|---|---|---|
| REQUIRED | 加入 | 新建 |
| REQUIRES_NEW | 挂起外部,新建 | 新建 |
| NESTED | 嵌套(savepoint) | 新建 |
| SUPPORTS | 加入 | 非事务 |
| NOT_SUPPORTED | 挂起外部,非事务 | 非事务 |
| MANDATORY | 加入 | 抛异常 |
| NEVER | 抛异常 | 非事务 |
10.4 循环依赖
// Spring 如何解决循环依赖?
// 答案:三级缓存
// 三级缓存结构
public class DefaultSingletonBeanRegistry {
// 一级缓存:完整 Bean(实例化 + 初始化)
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存:提前暴露的 Bean(实例化,未初始化)
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
// 三级缓存:Bean 工厂(用于生成代理对象)
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
}
// 解决流程:
// 1. A 实例化后,放入三级缓存
// 2. A 属性赋值时发现需要 B
// 3. B 实例化后,放入三级缓存
// 4. B 属性赋值时发现需要 A
// 5. 从三级缓存获取 A 的工厂,生成 A 的代理对象(如果需要)
// 6. B 初始化完成
// 7. A 继续初始化限制:
- 只能解决单例 Bean 的循环依赖(通过 setter 注入)
- 构造器注入的循环依赖无法解决
10.5 业界案例
| 公司 | 场景 | 实践 |
|---|---|---|
| 阿里巴巴 | 电商系统 | Spring Cloud + Nacos + Sentinel |
| 美团 | 外卖系统 | Spring Boot + 自定义 Starter |
| 字节跳动 | 微服务框架 | 自研 CloudWeGo(Go 版 Spring Cloud) |
11. 设计模式
11.1 单例模式
// 双重检查锁定(DCL)
public class Singleton {
private volatile static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
// 枚举方式(最推荐)
public enum SingletonEnum {
INSTANCE;
public void doSomething() {}
}
// 优点:线程安全、防止反射攻击、防止序列化问题11.2 工厂模式
// 简单工厂
public class ShapeFactory {
public static Shape getShape(String type) {
switch (type) {
case "circle": return new Circle();
case "rectangle": return new Rectangle();
default: throw new IllegalArgumentException();
}
}
}
// Spring 中的 FactoryBean
@Component
public class MyFactoryBean implements FactoryBean<MyObject> {
@Override
public MyObject getObject() {
return new MyObject();
}
@Override
public Class<?> getObjectType() {
return MyObject.class;
}
}11.3 代理模式
// 静态代理
public class UserServiceProxy implements UserService {
private UserService target;
public void save() {
System.out.println("Before");
target.save();
System.out.println("After");
}
}
// 动态代理(JDK)
UserService proxy = (UserService) Proxy.newProxyInstance(
loader,
new Class[]{UserService.class},
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) {
System.out.println("Before");
return method.invoke(target, args);
}
}
);11.4 观察者模式
// Spring Event 机制
@Component
public class OrderEventPublisher {
@Autowired
private ApplicationEventPublisher publisher;
public void publishOrderEvent(Order order) {
publisher.publishEvent(new OrderCreatedEvent(this, order));
}
}
@Component
public class OrderEventListener {
@EventListener
public void handleOrderCreated(OrderCreatedEvent event) {
// 处理订单创建事件
}
}11.5 策略模式
// 支付策略
public interface PaymentStrategy {
void pay(BigDecimal amount);
}
@Component
public class AlipayStrategy implements PaymentStrategy {
public void pay(BigDecimal amount) {
// 支付宝支付
}
}
@Component
public class WechatPayStrategy implements PaymentStrategy {
public void pay(BigDecimal amount) {
// 微信支付
}
}
@Service
public class PaymentService {
@Autowired
private Map<String, PaymentStrategy> strategies;
public void pay(String type, BigDecimal amount) {
PaymentStrategy strategy = strategies.get(type);
strategy.pay(amount);
}
}12. FAQ
Q1: Java 8 的新特性有哪些?
Lambda 表达式、Stream API、Optional、方法引用、接口默认方法、新的日期时间 API、CompletableFuture。
重点掌握:
- Stream 的惰性求值和短路操作
- CompletableFuture 的异步编程模型
- Optional 的正确使用方式(不要滥用)
Q2: == 和 equals 的区别?
==:比较引用地址(基本类型比较值)equals:比较内容(默认实现是==,需要重写)HashCode 契约:
- equals 相等 → hashCode 必须相等
- hashCode 相等 → equals 不一定相等
Q3: String、StringBuilder、StringBuffer 的区别?
| 维度 | String | StringBuilder | StringBuffer |
|---|---|---|---|
| 可变性 | 不可变 | 可变 | 可变 |
| 线程安全 | 安全(不可变) | 不安全 | 安全(synchronized) |
| 性能 | 低(每次创建新对象) | 高 | 中(同步开销) |
| 适用场景 | 字符串常量 | 单线程字符串拼接 | 多线程字符串拼接 |
Q4: 深拷贝和浅拷贝的区别?
浅拷贝:复制对象本身,对象内部的引用类型仍指向原对象。 深拷贝:递归复制对象及其所有引用类型。
实现方式:
- 浅拷贝:
clone()、BeanUtils.copyProperties()- 深拷贝:序列化、手动递归复制、JSON 转换
Q5: Java 的异常体系?
Throwable
├── Error(严重错误,不捕获)
│ ├── OutOfMemoryError
│ ├── StackOverflowError
│ └── ...
└── Exception(可捕获处理)
├── RuntimeException(运行时异常,不强制捕获)
│ ├── NullPointerException
│ ├── IllegalArgumentException
│ └── ...
└── Checked Exception(编译时异常,必须处理)
├── IOException
├── SQLException
└── ...
Q6: HashMap 和 ConcurrentHashMap 的区别?
线程安全:HashMap 不安全,ConcurrentHashMap 安全。 null 支持:HashMap 允许 null key/value,ConcurrentHashMap 不允许。 性能:单线程 HashMap 更快,多线程 ConcurrentHashMap 更优。
Q7: 什么是双亲委派模型?
类加载器层次:
- Bootstrap ClassLoader(加载 JDK 核心类)
- Extension ClassLoader(加载扩展类)
- Application ClassLoader(加载应用类)
委派流程:加载类时,先委托父加载器加载,父加载器无法加载时才自己加载。
优点:避免类的重复加载,保证核心类库安全。
Q8: JVM 内存模型和 JMM 的区别?
JVM 内存模型:JVM 运行时的内存区域划分(堆、栈、方法区等)。 JMM(Java Memory Model):多线程并发访问共享变量的规则规范。
关系:JMM 是抽象规范,JVM 内存模型是具体实现。
Q9: 如何排查内存泄漏?
- 监控:jstat、VisualVM 监控内存趋势
- dump:jmap 生成堆转储文件
- 分析:MAT(Memory Analyzer Tool)分析大对象、GC Roots
- 定位:找出持有引用链,确定泄漏点
常见原因:
- 静态集合持有对象引用
- 监听器未注销
- ThreadLocal 未 remove
- 数据库连接未关闭
Q10: Java 的反射有什么优缺点?
优点:
- 运行时动态获取类信息
- 实现框架的扩展性(Spring IoC、MyBatis)
缺点:
- 性能开销(绕过编译优化)
- 破坏封装性
- 代码可读性差
优化:
- 使用缓存(Method、Field 缓存)
- MethodHandle(Java 7+,性能更好)
- 使用字节码生成(ASM、CGLIB)
关联文档
| 主题 | 文档 |
|---|---|
| Go 并发对比 | 03-go-java-high-concurrency.md |
| Go vs Java 核心 | 09-java-to-go-core-principles.md |
| GMP 调度器 | 08-gmp-scheduler-and-memory-management.md |
| 高级面试题 | 11-go-advanced-interview-topics.md |
| Go 专家路线 | 14-go-expert-roadmap-java-to-go.md |
面试自检清单
JVM
- JMM happens-before 规则
- volatile 可见性和有序性
- synchronized 锁升级过程
- AQS 队列和 CAS
- 线程池参数调优
- ConcurrentHashMap 原理
- G1/ZGC GC 算法
- JVM 参数配置
Spring
- IoC Bean 生命周期
- AOP 动态代理
- 事务传播行为
- 循环依赖解决
- Spring Boot 自动配置
设计模式
- 单例(DCL + 枚举)
- 工厂模式
- 代理模式(JDK/CGLIB)
- 观察者模式
- 策略模式