java 内存结构面试要点

JVM 运行时数据区
├── 线程私有
│   ├── 程序计数器（PC Register）
│   ├── 虚拟机栈（VM Stack）
│   └── 本地方法栈（Native Method Stack）
└── 线程共享
    ├── 堆（Heap）
    └── 方法区（Method Area）/ 元空间（Metaspace）

// 线程 A 执行到第 10 行，被切换
// 线程 B 执行到第 20 行
// 切回 A 时，PC 指向 10，继续执行

public native void nativeMethod(); // PC = null

public void methodA() {
    int x = 1;      // 局部变量
    methodB();      // 调用 methodB，创建新栈帧
}

栈帧
├── 局部变量表（Local Variables）
├── 操作数栈（Operand Stack）
├── 动态链接（Dynamic Linking）
└── 返回地址（Return Address）

public void method(int a, String b) {
    int x = 1;
    Object obj = new Object();
}
// 局部变量表：
// slot 0: this
// slot 1: a
// slot 2: b
// slot 3: x
// slot 4: obj

int a = 1;
int b = 2;
int c = a + b;

iconst_1        // 压入 1
istore_1        // 弹出到 a
iconst_2        // 压入 2
istore_2        // 弹出到 b
iload_1         // 压入 a
iload_2         // 压入 b
iadd            // 弹出两个，相加，压回结果
istore_3        // 弹出到 c

public void recursive() {
    recursive(); // 无限递归
}
// 抛 StackOverflowError

-Xss1m  # 设置栈大小

-Xss512k   # 512KB
-Xss1m     # 1MB（默认）
-Xss2m     # 2MB

public native int hashCode();
public native void notify();

Object obj = new Object(); // obj 在堆

堆
├── 新生代（Young，1/3）
│   ├── Eden（8/10）
│   ├── Survivor0（1/10）
│   └── Survivor1（1/10）
└── 老年代（Old，2/3）

1. new 对象
   ↓
2. 栈上分配？（逃逸分析）→ 是 → 栈上分配
   ↓ 否
3. TLAB 分配？（线程本地缓冲）→ 是 → TLAB 分配
   ↓ 否
4. Eden 分配
   ↓
5. Eden 满 → Minor GC → 存活对象进 S0
   ↓
6. 再次 GC → S0 存活进 S1，年龄 +1
   ↓
7. 年龄达 15（-XX:MaxTenuringThreshold）→ 老年代

-XX:+UseTLAB           # 开启（默认）
-XX:TLABSize=256k      # 大小
-XX:-ResizeTLAB        # 禁止动态调整

// 1. 内存泄漏
List<Object> list = new ArrayList<>();
while (true) {
    list.add(new Object()); // 持续增长
}

// 2. 大对象
byte[] big = new byte[Integer.MAX_VALUE];

// 3. 超过最大堆

java.lang.OutOfMemoryError: Java heap space

-Xms512m   # 初始堆
-Xmx2g     # 最大堆
-XX:+HeapDumpOnOutOfMemoryError  # OOM 时 dump

// 堆共享，需同步
synchronized (obj) {
    obj.count++;
}

public void method() {
    Object obj = new Object(); // 未逃逸
    // 可能栈上分配
}

public Object method2() {
    return new Object(); // 逃逸
    // 堆上分配
}

-XX:+DoEscapeAnalysis  # 开启（默认）
-XX:+EliminateAllocations  # 标量替换

public class User {
    static int count = 0; // 静态变量
    public void method() {} // 方法信息
}

# JDK 7
-XX:PermSize=128m -XX:MaxPermSize=256m

# JDK 8+
-XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m

// 动态生成类，导致元空间 OOM
while (true) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Object.class);
    enhancer.create();
}

java.lang.OutOfMemoryError: Metaspace

public class Test {
    // 字面量
    private static final String S = "hello";
    private static final int N = 100;
    
    // 符号引用
    // 方法名、字段名、类名
}

String s1 = "hello";        // 常量池
String s2 = new String("hello"); // 堆
System.out.println(s1 == s2);     // false
System.out.println(s1 == s2.intern()); // true

public class User {
    static User instance = new User();
    // instance 引用在方法区
    // new User() 对象在堆
}

ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

// 堆内存
ByteBuffer heap = ByteBuffer.allocate(1024);

// 直接内存
ByteBuffer direct = ByteBuffer.allocateDirect(1024);

堆内存：堆 → 堆外 → 网卡（2 次拷贝）
直接内存：直接内存 → 网卡（1 次拷贝）

List<ByteBuffer> list = new ArrayList<>();
while (true) {
    list.add(ByteBuffer.allocateDirect(1024 * 1024));
}

java.lang.OutOfMemoryError: Direct buffer memory

-XX:MaxDirectMemorySize=256m  # 默认与 -Xmx 相同

// 手动释放（不推荐）
((DirectBuffer) buffer).cleaner().clean();

// 推荐：让 GC 自动回收
buffer = null;
System.gc(); // 触发 GC

Object obj = new Object();
// obj 引用在栈，对象在堆

# jps：查看 Java 进程
jps -l

# jstat：查看 GC 统计
jstat -gc <pid> 1000

# jmap：查看堆内存
jmap -heap <pid>
jmap -histo <pid>

# jstack：查看线程栈
jstack <pid>

# jcmd：综合工具
jcmd <pid> VM.memory

memory      # 内存使用
heapdump    # dump 堆

# 堆
-Xms2g                    # 初始堆
-Xmx4g                    # 最大堆
-Xmn1g                    # 新生代
-XX:NewRatio=2            # 老年代/新生代
-XX:SurvivorRatio=8       # Eden/Survivor

# 栈
-Xss1m                    # 每线程栈

# 元空间
-XX:MetaspaceSize=128m
-XX:MaxMetaspaceSize=512m

# 直接内存
-XX:MaxDirectMemorySize=256m

# OOM 时 dump
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path

总内存 = 堆 + 元空间 + 直接内存 + 线程栈 + JVM 自身

-XX:MaxDirectMemorySize  # 直接内存
-XX:MaxMetaspaceSize     # 元空间
-Xss                     # 线程栈

对象
├── Mark Word（8 字节）：hash、GC 年龄、锁状态
├── 类型指针（4/8 字节）：指向类元数据
├── 实例数据：字段
└── 对齐填充：补齐 8 的倍数