面试题集锦:Java 核心问答大全

面试题集锦:Java 核心问答大全

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


Generated by kimi-k2.6 model

面向 Senior/Staff 级别 Java 开发岗位的系统性面试准备文档。涵盖 JVM、并发、Spring、GC 等核心知识点,深度解析原理 + 实战 + 源码。


目录

  1. Java 核心基础
  2. JMM(Java 内存模型)
  3. volatile 关键字
  4. synchronized 原理
  5. AQS & Lock
  6. 线程池原理
  7. 并发容器
  8. GC 算法
  9. JVM 调优
  10. Spring 核心
  11. 设计模式
  12. 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

维度ArrayListLinkedList
底层结构动态数组双向链表
随机访问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 条规则:

  1. 程序次序规则:同一个线程中,前面的操作 happens-before 后面的操作
  2. 监视器锁规则:unlock happens-before 后面对同一个锁的 lock
  3. volatile 规则:对 volatile 变量的写 happens-before 后面对该变量的读
  4. 传递性:A happens-before B,B happens-before C,则 A happens-before C
  5. 线程启动规则:Thread.start() happens-before 线程中的每个操作
  6. 线程终止规则:线程中的所有操作 happens-before 线程的终止检测
  7. 中断规则:对线程 interrupt() 调用 happens-before 被中断线程检测到中断事件
  8. 对象终结规则:构造函数执行 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 = 42

2.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 JMMGo 内存模型C++ 内存模型
可见性保证volatile/synchronizedchannel/syncatomic/memory_order
重排序控制happens-beforehappens-beforememory_order
复杂性中等简单复杂
学习曲线陡峭平缓陡峭

2.5 业界案例

公司场景实践
阿里巴巴高并发交易系统volatile + CAS 实现无锁队列
美团订单状态同步volatile 保证状态可见性
LinkedIn实时推荐系统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 的区别?

维度volatilesynchronized
可见性✅✅
原子性❌✅
有序性✅✅
阻塞不会阻塞线程会阻塞线程
适用场景单一变量读写复合操作

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   // 释放 Monitor

Monitor 结构:

┌─────────────────────────────────────┐
│            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 的区别?

维度synchronizedReentrantLock
实现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 为什么用双向链表而不是单向链表?

  1. 取消节点:需要修改前驱节点的 next 指针,双向链表 O(1)
  2. 判断前驱状态:需要向前遍历找到 SIGNAL 状态的节点
  3. 避免死锁:单向链表在并发修改时容易出问题

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 对比:

维度ConcurrentHashMapHashTableCollections.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=4

8.4 CMS vs G1 对比

维度CMSG1
设计目标低延迟可预测停顿
内存碎片严重(标记-清除)轻微(标记-整理)
内存占用低高(Remembered Set)
大对象处理进入老年代专有 Humongous Region
JDK 版本JDK 14 已移除JDK 9+ 默认

8.5 业界案例

公司场景实践
阿里巴巴双十一大促G1 GC + 动态调参
美团外卖订单系统ZGC 超低延迟
LinkedIn实时推荐Shenandoah GC

8.6 FAQ

Q: Full GC 和 Minor GC 的区别?

Minor GC:回收新生代(Eden + Survivor),频率高,停顿短。 Full GC:回收整个堆(新生代 + 老年代 + 元空间),频率低,停顿长。

Q: 什么情况下会触发 Full GC?

  1. 老年代空间不足
  2. 元空间(Metaspace)不足
  3. System.gc() 调用(建议禁用)
  4. 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.hprof

9.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 降低到 50ms

9.4 FAQ

Q: 为什么要设置 Xms = Xmx?

避免 JVM 运行时动态扩缩堆内存,减少 GC 压力。启动时就分配好全部内存,性能更稳定。

Q: 如何判断 JVM 调优是否有效?

  1. GC 日志分析:停顿时间、频率
  2. 应用监控:响应时间 P99、吞吐量
  3. 资源监控: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 的区别?

维度StringStringBuilderStringBuffer
可变性不可变可变可变
线程安全安全(不可变)不安全安全(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: 什么是双亲委派模型?

类加载器层次:

  1. Bootstrap ClassLoader(加载 JDK 核心类)
  2. Extension ClassLoader(加载扩展类)
  3. Application ClassLoader(加载应用类)

委派流程:加载类时,先委托父加载器加载,父加载器无法加载时才自己加载。

优点:避免类的重复加载,保证核心类库安全。

Q8: JVM 内存模型和 JMM 的区别?

JVM 内存模型:JVM 运行时的内存区域划分(堆、栈、方法区等)。 JMM(Java Memory Model):多线程并发访问共享变量的规则规范。

关系:JMM 是抽象规范,JVM 内存模型是具体实现。

Q9: 如何排查内存泄漏?

  1. 监控:jstat、VisualVM 监控内存趋势
  2. dump:jmap 生成堆转储文件
  3. 分析:MAT(Memory Analyzer Tool)分析大对象、GC Roots
  4. 定位:找出持有引用链,确定泄漏点

常见原因:

  • 静态集合持有对象引用
  • 监听器未注销
  • ThreadLocal 未 remove
  • 数据库连接未关闭

Q10: Java 的反射有什么优缺点?

优点:

  • 运行时动态获取类信息
  • 实现框架的扩展性(Spring IoC、MyBatis)

缺点:

  • 性能开销(绕过编译优化)
  • 破坏封装性
  • 代码可读性差

优化:

  • 使用缓存(Method、Field 缓存)
  • MethodHandle(Java 7+,性能更好)
  • 使用字节码生成(ASM、CGLIB)

关联文档


面试自检清单

JVM

  • JMM happens-before 规则
  • volatile 可见性和有序性
  • synchronized 锁升级过程
  • AQS 队列和 CAS
  • 线程池参数调优
  • ConcurrentHashMap 原理
  • G1/ZGC GC 算法
  • JVM 参数配置

Spring

  • IoC Bean 生命周期
  • AOP 动态代理
  • 事务传播行为
  • 循环依赖解决
  • Spring Boot 自动配置

设计模式

  • 单例(DCL + 枚举)
  • 工厂模式
  • 代理模式(JDK/CGLIB)
  • 观察者模式
  • 策略模式