操作数栈（栈顶缓存/字节码指令分析）

操作数栈：字节码指令的「工作台」

如果说局部变量表是「仓库」，那操作数栈就是字节码执行时的「工作台」。JVM 基于栈的执行模型中，所有计算都在操作数栈上完成。

操作数栈的工作原理

操作数栈是一个后进先出（LIFO）的栈。字节码指令从操作数栈读取操作数，计算结果再压回栈顶。

简单的计算过程

public int compute() {
    int a = 10;
    int b = 20;
    return a + b;
}

对应的字节码执行过程：

初始状态：操作数栈为空

iconst_10     → 压入 10     → 栈：[10]
istore_1      → 弹出 10，存到 slot 1  → 栈：[]
iconst_20     → 压入 20     → 栈：[20]
istore_2      → 弹出 20，存到 slot 2  → 栈：[]
iload_1       → 加载 slot 1  → 栈：[10]
iload_2       → 加载 slot 2  → 栈：[10, 20]
iadd          → 弹出 20、10，相加，   → 栈：[30]
                结果 30 入栈
ireturn       → 返回栈顶值

复杂表达式

public int complex() {
    return (1 + 2) * 3;
}

字节码：

iconst_1       // 1 入栈    → 栈：[1]
iconst_2       // 2 入栈    → 栈：[1, 2]
iadd           // 1+2=3 入栈 → 栈：[3]
iconst_3       // 3 入栈    → 栈：[3, 3]
imul           // 3*3=9 入栈 → 栈：[9]
ireturn

dup + swap 的妙用

public String dupDemo() {
    String s = "hello";
    return s + s;  // 两次使用 s
}

字节码中，「两次使用」需要栈上有两个副本：

ldc "hello"    // 字符串引用入栈  → 栈：[ref_s]
dup             // 复制栈顶        → 栈：[ref_s, ref_s]
astore_1        // 弹出第一个存到 slot 1  → 栈：[ref_s]
// ... 稍后使用 slot 1 加载第二个 ref

dup 指令复制栈顶元素，swap 交换栈顶两个元素——这是处理复杂表达式时的重要工具。

栈顶缓存技术（Top-of-Stack Caching）

HotSpot 的 JIT 编译器有一个优化技术叫栈顶缓存（Top-of-Stack Caching）。

为什么不直接把值存在寄存器里

JVM 是基于栈的虚拟机，指令中不指定操作数位置，默认从操作数栈读写。但寄存器比内存快得多。

优化思路

HotSpot 的解释器会尝试把栈顶的少量值缓存在物理寄存器中，减少对操作数栈的访问：

优化前：每条指令都需要操作数栈的内存访问
优化后：热点数据在寄存器中，避免频繁内存访问

这种优化在解释执行时效果显著。JIT 编译后，由于寄存器分配优化，栈顶缓存的优化空间变小——JIT 编译器会直接把热点数据分配到真实寄存器中。

操作数栈的深度

操作数栈的最大深度是在编译时确定的，记录在 Class 文件的方法属性中。

查看方法的最大栈深度

javap -verbose MyClass.class | grep -A 5 "Stack:"

// 编译这个方法
public class StackDepth {
    public int compute() {
        int a = 1, b = 2, c = 3, d = 4;
        return ((a + b) * c) + d;
    }
}

javap -c 输出：

public int compute();
    Code:
      stack=3   ← 最大操作数栈深度是 3
      locals=5  ← 局部变量表有 5 个 slot
      ...

      iconst_1
      istore_1
      iconst_2
      istore_2
      ...（省略）

深度溢出的危险

操作数栈深度超过方法设定的最大值，会触发 JVM 的 StackOverflowError——这通常意味着字节码验证失败（生成的字节码本身就有问题）。

字节码指令分类

与操作数栈直接相关的字节码指令分为几类：

入栈指令（Load）

指令	含义
iconst_<n>	将 int 常量 n 入栈
aconst_null	null 入栈
bipush <byte>	byte 扩展为 int 入栈
sipush <short>	short 扩展为 int 入栈
ldc <index>	常量池第 index 项入栈
iload <n>	slot n 的 int 值入栈
iload_<n>	slot 0-3 的 int 值入栈
aload <n>	slot n 的 reference 入栈

出栈指令（Store）

指令	含义
istore_<n>	弹出 int 值存入 slot n
istore <n>	弹出 int 值存入 slot n
astore <n>	弹出 reference 存入 slot n
pop	弹出栈顶值（丢弃）
pop2	弹出栈顶两个值

运算指令

指令	含义
iadd、isub、imul、idiv	int 加减乘除
irem、ineg	int 取模、取反
iand、ior、ixor	int 位与/或/异或

操作数栈与多态

invokevirtual 的执行过程

public class Polymorphic {
    static class Animal { void speak() { System.out.println("..."); } }
    static class Cat extends Animal { @Override void speak() { System.out.println("Meow"); } }

    public static void main(String[] args) {
        Animal a = new Cat();
        a.speak();  // 多态调用
    }
}

字节码：

new #2        // new Cat()   → 操作数栈：[Cat 对象引用]
dup            // 复制引用    → 操作数栈：[Cat ref, Cat ref]
invokespecial #3  // 调用构造器，消耗一个 ref
astore_1       // 存到 slot 1
aload_1         // 加载 slot 1  → 栈：[Cat ref]
invokevirtual #4  // 多态调用
// 栈顶的引用被弹出，找到实际类型，调用正确的方法

invokevirtual 执行时：

1. 弹出栈顶的 reference
2. 根据 reference 找到对象的实际类型
3. 在方法表中查找方法
4. 调用目标方法

这就是运行时多态的底层机制。

本节小结

操作数栈是 JVM 基于栈执行模型的核心：

关键点	说明
LIFO 栈	所有操作都在栈顶进行
编译时确定	最大深度记录在 Class 文件的 Stack 属性中
类型敏感	int/long/float/double/ reference 各有专用指令
栈顶缓存	HotSpot 的解释器优化，减少栈访问
dup/swap	复制和交换栈顶元素，处理复杂表达式

理解操作数栈，是理解字节码执行过程的关键。下一节，我们来看 动态链接（常量池/静态/动态绑定）。