运行时数据区

┌─────────────────────────────────────────────────────────────┐
│                    JVM 运行时数据区                           │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  程序计数器   │   虚拟机栈   │  本地方法栈  │      堆          │
│  (线程私有)   │  (线程私有)  │  (线程私有)  │   (线程共享)     │
├─────────────┴─────────────┴─────────────┼─────────────────┤
│                  方法区                   │ 运行时常量池      │
│               (线程共享)                  │ (方法区一部分)    │
└─────────────────────────────────────────┴─────────────────┘

// Java 代码
int a = 1;
int b = 2;
int c = a + b;
 
// 字节码
0: iconst_1      // PC = 0
1: istore_1      // PC = 1
2: iconst_2      // PC = 2
3: istore_2      // PC = 3
4: iload_1       // PC = 4
5: iload_2       // PC = 5
6: iadd          // PC = 6
7: istore_3      // PC = 7

┌────────────────────────┐
│        栈帧            │
├────────────────────────┤
│  局部变量表             │
│  (Local Variables)     │
├────────────────────────┤
│  操作数栈               │
│  (Operand Stack)       │
├────────────────────────┤
│  动态链接               │
│  (Dynamic Linking)     │
├────────────────────────┤
│  方法返回地址           │
│  (Return Address)      │
└────────────────────────┘

public int add(int a, int b) {
    int c = a + b;
    return c;
}
 
// 局部变量表
// slot 0: this（非静态方法）
// slot 1: a
// slot 2: b
// slot 3: c

int c = a + b;
 
// 字节码执行过程
iload_1    // 将 a 压入操作数栈
iload_2    // 将 b 压入操作数栈
iadd       // 弹出两个值相加，结果压栈
istore_3   // 弹出结果存入局部变量表

# 设置每个线程栈大小
-Xss256k

// Object.hashCode() 是本地方法
public native int hashCode();
 
// Thread.start() 调用本地方法
private native void start0();

┌─────────────────────────────────────────────┐
│                   堆 (Heap)                  │
├─────────────────────┬───────────────────────┤
│    新生代 (Young)    │     老年代 (Old)       │
├─────────┬─────────┬─┴───────────────────────┤
│   Eden  │ Survivor │                         │
│         │  S0  S1  │                         │
│  8 : 1  :   1      │                         │
└─────────┴─────────┴─────────────────────────┘

新对象
   ↓
Eden 区分配 → 空间足够？
   ↓ 否
触发 Minor GC
   ↓
存活对象 → Survivor 区 → 年龄 +1
   ↓
年龄 ≥ 15 (默认) → 晋升老年代

// 大对象：需要大量连续内存的对象（长数组、大字符串）
// -XX:PretenureSizeThreshold 设置阈值
 
byte[] bigArray = new byte[4 * 1024 * 1024];  // 4MB，可能直接进老年代

# 初始堆大小
-Xms512m
 
# 最大堆大小
-Xmx1024m
 
# 新生代比例
-XX:NewRatio=2        # 老年代:新生代 = 2:1
 
# Eden:Survivor 比例
-XX:SurvivorRatio=8   # Eden:S0:S1 = 8:1:1

// 堆溢出
List<byte[]> list = new ArrayList<>();
while (true) {
    list.add(new byte[1024 * 1024]);  // 持续创建大对象
}
// java.lang.OutOfMemoryError: Java heap space

方法区
├── 类信息
│   ├── 类名、访问修饰符
│   ├── 父类、接口
│   ├── 字段、方法
│   └── 方法字节码
├── 运行时常量池
├── 静态变量
└── 即时编译代码

# JDK8+ 元空间
-XX:MetaspaceSize=128m      # 初始大小
-XX:MaxMetaspaceSize=256m   # 最大大小

// 字符串常量池示例
String s1 = "hello";           // 常量池
String s2 = "hello";           // 复用常量池中的对象
String s3 = new String("hello"); // 堆中新建对象
 
System.out.println(s1 == s2);  // true
System.out.println(s1 == s3);  // false
System.out.println(s1 == s3.intern()); // true
 
// intern() 方法：将字符串加入常量池并返回引用

// JDK6 会 OOM
// JDK7+ 常量池在堆中，受堆大小限制
List<String> list = new ArrayList<>();
int i = 0;
while (true) {
    list.add(String.valueOf(i++).intern());
}

// 使用直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
 
// 底层使用 Unsafe 分配本地内存
// 访问更快，但分配/释放开销更大

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

┌────────────────────────────────────┐
│           对象头 (Header)           │
├────────────────────────────────────┤
│  Mark Word (8 bytes)               │
│  - 哈希码、锁状态、GC 年龄           │
├────────────────────────────────────┤
│  类型指针 (4/8 bytes)               │
│  - 指向类元数据                     │
├────────────────────────────────────┤
│  实例数据 (Instance Data)           │
│  - 字段值                          │
├────────────────────────────────────┤
│  对齐填充 (Padding)                 │
│  - 保证 8 字节对齐                  │
└────────────────────────────────────┘

// 64 位 JVM，开启指针压缩
Object obj = new Object();  // 16 字节
// Mark Word: 8 字节
// 类型指针: 4 字节（压缩后）
// 对齐填充: 4 字节
 
// 数组对象额外 4 字节存储长度
int[] arr = new int[10];    // 16 + 40 = 56 字节

// CGLib 动态代理生成大量类
while (true) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Object.class);
    enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> null);
    enhancer.create();  // 不断生成新类
}
// java.lang.OutOfMemoryError: Metaspace

# 1. 打印 GC 日志
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log
 
# 2. OOM 时生成堆转储
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=dump.hprof
 
# 3. 使用工具分析
jmap -histo:live <pid>     # 查看对象统计
jhat dump.hprof            # 分析堆转储
MAT / VisualVM             # 可视化工具