JTechVault

Appearance

动态链接（常量池/静态/动态绑定） ​

动态链接：栈帧与常量池的桥梁 ​

每个栈帧都有一个指向运行时常量池的引用，这就是动态链接。它是把字节码中的符号引用在运行时解析成直接引用的关键机制。

常量池：Class 文件中的「数据仓库」 ​

在理解动态链接之前，需要先理解常量池。

什么是常量池 ​

常量池（Constant Pool）是 Class 文件中最大的一个区域，存放了类名、方法名、字段名、字符串常量等几乎所有的「常量」信息。

ClassFile {
    ...
    constant_pool_count: 15      // 常量池中有 14 项（index 1~14）
    constant_pool[14]:           // 第 0 项不用（保留）
      [1] CONSTANT_Class        → #2  → "java/lang/String"
      [2] CONSTANT_Utf8         → "java/lang/String"
      [3] CONSTANT_Methodref     → #1.#4
      [4] CONSTANT_NameAndType  → "<init>":()V
      ...
}

常量池中的内容 ​

常量池中存放两大类数据：

类型存储内容
字面量（Literal）字符串常量（"hello"）、数值常量（123、3.14）、final 常量
符号引用（Symbolic Reference）类、接口、字段、方法的符号引用

运行时常量池 ​

常量池被加载到内存后，就变成了运行时常量池，存放在方法区（元空间）中。

java
public class RuntimeConstantPool {
    public static void main(String[] args) {
        // 字符串 "hello" 进入运行时常量池
        String s = "hello";

        // Integer.valueOf(127) 的缓存也在常量池范围内
        Integer i1 = 127;
        Integer i2 = 127;
        System.out.println(i1 == i2);  // true（常量池缓存）
    }
}

静态绑定 vs 动态绑定 ​

绑定（Binding）指的是把符号引用解析成直接引用的过程。JVM 中有两种绑定方式：

绑定方式时机含义
静态绑定编译时符号引用在编译时就已确定，运行时不改变
动态绑定运行时符号引用在运行时才确定具体指向哪个实现

静态绑定：非虚方法 ​

private、static、final 方法以及构造器，是非虚方法，使用静态绑定。

java
public class StaticBinding {
    private static void staticMethod() { }  // 静态绑定
    private void privateMethod() { }         // 静态绑定
    public final void finalMethod() { }     // 静态绑定

    public static void main(String[] args) {
        StaticBinding obj = new StaticBinding();
        obj.privateMethod();  // 编译时就确定了调用目标
    }
}

动态绑定：虚方法 ​

实例方法（instance method）默认是虚方法，使用动态绑定。

java
public class DynamicBinding {
    static class Parent {
        void method() { System.out.println("Parent"); }
    }
    static class Child extends Parent {
        @Override
        void method() { System.out.println("Child"); }
    }

    public static void main(String[] args) {
        Parent obj = new Child();  // 父类引用指向子类对象
        obj.method();              // 运行时才知道调用 Child 的 method
    }
}

虚方法表（vtable） ​

动态绑定的实现依赖于虚方法表（Virtual Method Table，vtable）。每个类都有一个 vtable，包含了该类所有可被重写的方法的实际地址。

Parent 类的 vtable：
  slot 0: method() → Parent.method() 的地址
  slot 1: toString() → Parent.toString() 的地址

Child 类的 vtable：
  slot 0: method() → Child.method() 的地址（覆盖了 Parent）
  slot 1: toString() → Parent.toString() 的地址（继承，未覆盖）

动态绑定时，执行引擎只需要：

  1. 根据对象的实际类型找到对应的 vtable
  2. 在 vtable 中查找方法的 slot
  3. 跳转到目标地址执行

这就是 invokevirtual 指令的运行时机制。

动态链接的工作过程 ​

字节码中的符号引用：
  invokespecial #3
         │
         │  #3 指向常量池条目 CONSTANT_Methodref
         ▼
运行时常量池
  CONSTANT_Methodref {
    class_index: 指向类 "com/example/Parent"
    name_and_type_index: "method":()V
  }
         │
         │  解析过程：
         │  1. 找到 Parent 类
         │  2. 在 Parent 的方法表中找到 method()
         │  3. 获取 method() 的直接引用（内存地址）
         ▼
直接引用：
  Parent.method() 在方法区中的入口地址
         │
         ▼
执行引擎跳转到该地址，执行方法

方法区与常量池的关系 ​

方法区存储类的元信息，运行时常量池是方法区的一部分。

方法区 / 元空间
    │
    ├── 类信息（类名、父类、修饰符）
    ├── 方法表
    ├── 字段表
    ├── 字节码
    └── 运行时常量池
           ├── 字符串常量（StringTable）
           ├── 数值常量
           ├── 类/方法/字段的符号引用
           └── 方法类型签名

JDK 8 之后，方法区改用 Metaspace 实现，运行时常量池也随之进入 Metaspace。

动态链接与多态 ​

多态是动态链接最直接的应用场景：

java
public class PolymorphismLink {
    static abstract class Animal {
        abstract void speak();
    }
    static class Dog extends Animal {
        @Override
        void speak() { System.out.println("汪"); }
    }
    static class Cat extends Animal {
        @Override
        void speak() { System.out.println("喵"); }
    }

    public static void main(String[] args) {
        Animal[] animals = { new Dog(), new Cat() };
        for (Animal a : animals) {
            a.speak();  // 运行时动态绑定
        }
    }
}

字节码中的 invokevirtual 指令不包含具体的方法地址，而是通过对象的 vtable 在运行时确定调用目标。

静态绑定的性能优势 ​

静态绑定的方法调用比动态绑定快，因为不需要运行时查找：

java
public class BindingPerformance {
    // 静态绑定：编译时就确定了
    public static void staticCall() { }

    // 动态绑定：需要运行时查 vtable
    public void dynamicCall() { }

    public static void main(String[] args) {
        staticCall();         // 更快的调用
        new BindingPerformance().dynamicCall();  // 需要动态分派
    }
}

JIT 编译器会做进一步的优化，比如内联（把被调用方法的代码直接嵌入调用点），这样即使是动态绑定的虚方法，也能在运行时被优化掉。

本节小结 ​

动态链接是 JVM 实现多态的核心机制：

概念说明
常量池Class 文件中的常量信息表，存放字面量和符号引用
运行时常量池常量池进入内存后的形态，存在于方法区/元空间
静态绑定非虚方法在编译时确定调用目标
动态绑定虚方法在运行时通过 vtable 确定调用目标
虚方法表每个类维护的方法地址表，支持运行时多态

动态链接让 JVM 能够在一个类加载完成后，通过符号引用找到真正要执行的方法，实现了 Java 的运行时多态特性。

下一节，我们来看 方法调用指令（非虚/虚方法/invokedynamic），深入理解 JVM 的方法分派机制。

基于 VitePress 构建

Copyright © 2025-2026 JTechVault