Java语言特性与JVM基础

面试重要程度：⭐⭐⭐⭐⭐

常见提问方式：JVM内存模型、垃圾回收机制、类加载过程

预计阅读时间：30分钟

开篇

兄弟，这章绝对是重中之重！JVM相关的问题在面试中出现频率超高，基本上每个面试官都会问。而且这些问题往往能看出你的技术深度，所以一定要好好掌握。

我见过太多人在这里栽跟头，明明其他方面都不错，就是JVM这块答不上来，结果就挂了。今天我们就把这些核心知识点彻底搞清楚。

🚀 3.1 Java 17+新特性面试要点

Record类（面试高频）

什么是Record类？Record是Java 14引入的预览特性，Java 17正式发布。它是一种特殊的类，专门用来存储数据。

面试中这样问：

面试官："你了解Java的Record类吗？它解决了什么问题？"

标准回答：

// 传统写法（繁琐）
public class User {
    private final String name;
    private final int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    
    @Override
    public boolean equals(Object obj) {
        // 一堆代码...
    }
    
    @Override
    public int hashCode() {
        // 一堆代码...
    }
    
    @Override
    public String toString() {
        // 一堆代码...
    }
}

// Record写法（简洁）
public record User(String name, int age) {
    // 自动生成构造器、getter、equals、hashCode、toString
    
    // 可以添加自定义方法
    public boolean isAdult() {
        return age >= 18;
    }
    
    // 可以添加验证逻辑
    public User {
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
    }
}

使用场景：

• DTO对象
• 配置类
• 返回多个值的方法
• 不可变数据载体

虚拟线程（Project Loom）

面试重点：

面试官："听说过虚拟线程吗？它和传统线程有什么区别？"

核心概念：

// 传统线程创建（重量级）
Thread thread = new Thread(() -> {
    // 执行任务
});
thread.start();

// 虚拟线程创建（轻量级）
Thread virtualThread = Thread.ofVirtual().start(() -> {
    // 执行任务
});

// 或者使用Executors
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        // 高并发IO任务
        return "result";
    });
}

虚拟线程的优势：

1. 轻量级：创建成本极低，可以创建百万级别
2. 高并发：特别适合IO密集型任务
3. 简化编程：不需要异步回调，代码更直观

适用场景：

• Web服务器处理大量请求
• 数据库连接池
• 网络IO操作
• 文件处理

Pattern Matching（模式匹配）

面试考点：

// instanceof的模式匹配（Java 17）
public String formatObject(Object obj) {
    if (obj instanceof String s) {
        return "String: " + s.toUpperCase();
    } else if (obj instanceof Integer i) {
        return "Integer: " + (i * 2);
    } else if (obj instanceof List<?> list) {
        return "List size: " + list.size();
    }
    return "Unknown type";
}

// Switch表达式的模式匹配（预览特性）
public String processValue(Object value) {
    return switch (value) {
        case String s -> "String: " + s;
        case Integer i -> "Integer: " + i;
        case null -> "Null value";
        default -> "Unknown: " + value.toString();
    };
}

🧠 3.2 JVM内存结构深度解析

内存区域划分

面试必问：

面试官："说说JVM的内存结构，每个区域存储什么内容？"

标准回答框架：

JVM内存主要分为以下几个区域：

1. 程序计数器（PC Register）
2. 虚拟机栈（VM Stack）  
3. 本地方法栈（Native Method Stack）
4. 堆内存（Heap）
5. 方法区（Method Area）/元空间（Metaspace）
6. 直接内存（Direct Memory）

详细解析：

1. 程序计数器

// 程序计数器记录当前线程执行的字节码指令地址
public void method() {
    int a = 1;    // PC指向这条指令的地址
    int b = 2;    // PC指向下一条指令的地址
    int c = a + b; // PC继续向下
}

特点：

• 线程私有
• 不会发生OutOfMemoryError
• 执行Java方法时记录字节码指令地址
• 执行Native方法时为空

2. 虚拟机栈

public class StackDemo {
    public void methodA() {
        int localVar = 10;
        methodB();  // 创建新的栈帧
    }
    
    public void methodB() {
        String str = "hello";
        // methodB的栈帧在methodA的栈帧之上
    }
}

栈帧结构：

• 局部变量表
• 操作数栈
• 动态链接
• 方法返回地址

常见异常：

// StackOverflowError示例
public void recursiveMethod() {
    recursiveMethod(); // 无限递归导致栈溢出
}

3. 堆内存（重点）

堆内存分代模型：

堆内存
├── 新生代（Young Generation）
│   ├── Eden区
│   ├── Survivor0区（From）
│   └── Survivor1区（To）
└── 老年代（Old Generation）

对象分配流程：

public class HeapDemo {
    public static void main(String[] args) {
        // 1. 新对象在Eden区分配
        String str1 = new String("hello");
        
        // 2. Eden区满了触发Minor GC
        // 3. 存活对象移到Survivor区
        // 4. 经过多次GC后移到老年代
        
        // 大对象直接进入老年代
        byte[] bigArray = new byte[1024 * 1024 * 10]; // 10MB
    }
}

面试常问：

面试官："对象什么时候会进入老年代？"

标准答案：
1. 大对象直接进入老年代（-XX:PretenureSizeThreshold）
2. 长期存活的对象（默认15次GC后）
3. Survivor区空间不足时
4. 动态年龄判定（相同年龄对象大小超过Survivor一半）

方法区/元空间

JDK版本变化：

JDK 7及以前：永久代（PermGen）
JDK 8及以后：元空间（Metaspace）

存储内容：

• 类的元数据信息
• 常量池
• 方法字节码
• JIT编译后的代码

面试题：

// 字符串常量池的变化
public class StringPoolDemo {
    public static void main(String[] args) {
        String str1 = "hello";           // 常量池
        String str2 = new String("hello"); // 堆内存
        String str3 = str2.intern();     // 返回常量池引用
        
        System.out.println(str1 == str2); // false
        System.out.println(str1 == str3); // true
    }
}

🗑️ 3.3 垃圾回收器选择与调优

垃圾回收算法

面试必问：

面试官："说说常见的垃圾回收算法，各有什么优缺点？"

1. 标记-清除算法

优点：实现简单
缺点：产生内存碎片，效率不高

适用场景：老年代回收

2. 复制算法

// 复制算法示例（新生代使用）
// Eden区 + Survivor0区 → Survivor1区
// 比例通常是 8:1:1

3. 标记-整理算法

优点：不产生碎片，内存利用率高
缺点：需要移动对象，效率较低

适用场景：老年代回收

4. 分代收集算法

// 现代JVM的标准做法
// 新生代：复制算法（对象存活率低）
// 老年代：标记-清除或标记-整理（对象存活率高）

垃圾收集器对比

面试重点：各收集器的特点和适用场景

1. Serial收集器

# 单线程收集器
-XX:+UseSerialGC

特点：
- 单线程执行
- 适合小型应用
- 客户端模式默认选择

2. Parallel收集器

# 并行收集器（JDK 8默认）
-XX:+UseParallelGC

特点：
- 多线程并行收集
- 吞吐量优先
- 适合后台计算任务

3. CMS收集器

# 并发标记清除收集器
-XX:+UseConcMarkSweepGC

特点：
- 低延迟
- 并发收集
- 会产生碎片

4. G1收集器

# G1收集器（JDK 9+默认）
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200

特点：
- 低延迟（目标<10ms）
- 大堆内存友好（>4GB）
- 可预测的停顿时间

5. ZGC收集器

# ZGC收集器（JDK 11+）
-XX:+UseZGC

特点：
- 超低延迟（<1ms）
- 支持TB级堆内存
- 并发收集

GC调优实战

面试场景：

面试官："你们生产环境用的什么GC？为什么选择它？遇到过什么GC问题？"

回答模板：

// 我们的调优案例
// 应用场景：电商系统，8GB堆内存，要求低延迟

// 调优前：Parallel GC
// 问题：Full GC频繁，每次停顿2-3秒

// 调优后：G1 GC
-Xms8g -Xmx8g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100
-XX:G1HeapRegionSize=16m

// 效果：
// GC停顿时间从2-3秒降到100ms以内
// 吞吐量基本不变
// 系统响应时间明显改善

常见GC问题排查：

# 1. 查看GC日志
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps

# 2. 分析内存使用
jstat -gc pid 1000

# 3. 生成堆转储
jmap -dump:format=b,file=heap.hprof pid

# 4. 分析堆转储
# 使用MAT或VisualVM分析

🔄 3.4 类加载机制

类加载过程

面试必问：

面试官："说说类加载的过程，每个阶段做什么？"

类加载的七个阶段：

1. 加载（Loading）
2. 验证（Verification）
3. 准备（Preparation）
4. 解析（Resolution）
5. 初始化（Initialization）
6. 使用（Using）
7. 卸载（Unloading）

详细解析：

public class ClassLoadingDemo {
    // 准备阶段：静态变量分配内存，设置默认值
    private static int count = 100;  // 准备阶段设为0，初始化阶段设为100
    
    // 初始化阶段：执行静态代码块
    static {
        System.out.println("类初始化");
        count = 200;
    }
    
    public static void main(String[] args) {
        System.out.println(count); // 输出200
    }
}

类加载器

双亲委派模型：

// 类加载器层次结构
Bootstrap ClassLoader（启动类加载器）
    ↓
Extension ClassLoader（扩展类加载器）
    ↓
Application ClassLoader（应用程序类加载器）
    ↓
Custom ClassLoader（自定义类加载器）

双亲委派机制：

protected Class<?> loadClass(String name, boolean resolve) {
    // 1. 检查类是否已经加载
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        try {
            if (parent != null) {
                // 2. 委派给父加载器
                c = parent.loadClass(name, false);
            } else {
                // 3. 委派给启动类加载器
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // 父加载器无法加载
        }
        
        if (c == null) {
            // 4. 自己尝试加载
            c = findClass(name);
        }
    }
    return c;
}

面试常问：

面试官："为什么要使用双亲委派模型？"

标准答案：
1. 避免类的重复加载
2. 保证Java核心API不被篡改
3. 提供统一的类加载机制
4. 保证类加载的安全性

💡 面试重点总结

高频面试题

1. JVM内存模型

必答要点：
- 堆、栈、方法区的作用
- 新生代和老年代的划分
- 对象分配和回收流程

2. GC算法和收集器

必答要点：
- 各种GC算法的优缺点
- 不同收集器的适用场景
- GC调优的思路和方法

3. 类加载机制

必答要点：
- 类加载的过程
- 双亲委派模型
- 自定义类加载器的应用

答题技巧

技巧1：结合实际项目

不要只说理论，要结合具体场景：
"我们项目中遇到Full GC频繁的问题，通过分析GC日志发现..."

技巧2：展示解决问题的能力

"当时系统出现内存泄漏，我通过jmap生成堆转储文件，用MAT分析后发现..."

技巧3：体现持续学习

"最近在关注ZGC的发展，它的低延迟特性很适合我们的实时系统..."

总结

JVM这块知识点虽然复杂，但是有规律可循。面试官主要考察：

1. 基础概念是否清楚：内存结构、GC算法、类加载
2. 实际经验是否丰富：调优经验、问题排查
3. 学习能力是否强：新特性了解、技术发展趋势

记住，理论+实践+思考 是回答JVM问题的三要素。不要死记硬背，要理解原理，结合实际项目经验来回答。

本章核心要点：

• ✅ Java 17+新特性（Record、虚拟线程、模式匹配）
• ✅ JVM内存结构详解（堆、栈、方法区）
• ✅ 垃圾回收算法和收集器对比
• ✅ 类加载机制和双亲委派模型
• ✅ GC调优实战经验和问题排查

下一章预告： 集合框架源码剖析 - HashMap、ConcurrentHashMap等核心实现原理