Java 内存分配

更多 Java 虚拟机方面的文章，请参见文集《Java 虚拟机》

Java 内存分配

下图引用于 Import New 文章

Java 内存分配

Method Area：方法区，存储类的结构，包括常量池，成员变量，成员方法。Class Area 中的对象可共享，生命周期确定。
Heap：存储对象。堆中的对象不可共享，生命周期不确定，由 GC 控制。
Stack：存储局部变量，方法调用及返回。栈中的对象可共享，生命周期确定，存取速度比堆快。
PC Register：存储 JVM 指令地址
Native Method Stack：存储本地方法栈

例如，Student s = new Student(); 这段代码中：

new 出来的对象存放在堆中 Heap
引用变量 s 存放在栈中 Stack，s 的值为对象在堆中的地址，相当于指针
若程序离开了这段代码所在的方法或代码块：
- 栈中的引用变量 s 会被释放，占用的内存空间被释放。因此说 栈中的对象生命周期确定。
- 堆中的对象不会被释放，但是被变成垃圾，不能使用，由 GC 负责定期回收，在回收之前，该对象仍然会占据内存空间。因此说 堆中的对象生命周期不确定。

常量池 Constant Pool

编译时确定，存在放 .class 文件中。
好处：节省内存，节省运行时间。

直接常量，例如 final int i = 123; String s = "abc";
符号引用，包括：
- 类，接口全限定名
- 字段的名称和描述符
- 方法的名称和描述符

示例

示例1： i 和 j 都在栈中，值为 1

int i = 1;
int j = 1;

示例2： i 和 j 都在栈中，指向的 1 在常量池中

static final int i = 1;
static final int j = 1;

示例3： i 和 j 都在栈中，指向的 1 在常量池中
原因参见 Java AutoBoxing&UnBoxing 自动装箱与自动拆箱

Integer i = 1;
Integer j = 1;

示例4： i 和 j 都在栈中，指向的 1 在堆中，且分别对应堆中的两个不同对象

Integer i = new Integer(1);
Integer j = new Integer(1);

父类对象与子类对象

假设父类 Base 占据 1M 空间，子类 Derived 里的变量占据 0.5M 空间。

static class Base {
    public String b_name;

    public Base(String b_name) {
        this.b_name = b_name;
    }
}

static class Derived extends Base {
    public String d_name;

    public Derived(String b_name, String d_name) {
        super(b_name);
        this.d_name = d_name;
    }
}

示例：
Base b = new Base("123"); 在堆中分配 1M 的空间
Derived d = new Derived("123", "321"); 在堆中分配 1.5M 的空间，子类中包含了引用 supre 指向父类的实例，先调用父类的构造函数 super();

Derived d2 = d; d2 指向了 d 中的 1.5M 空间，无需在堆中再次分配空间，即 d2 和 d 指向堆中的同一个对象

d2.d_name = "1234"; 由于 d2 和 d 指向堆中的同一个空间，即同一个对象，因此通过 d2 进行的改变，也会影响到 d

Base b2 = d; b2 会指向 d 中的 1M 空间，即父类实例对应的堆中空间，因此 b2 只能访问父类的方法和变量，例如 b_name，不能访问子类的方法和变量，例如 d_name

Derived d3 = (Derived)b; 编译通过，运行报错 ClassCastException，因为 b 只有 1M，而 d3 需要 1.5M

Derived d3 = (Derived)b2; 编译通过，运行通过，因为 b2 由 d 转换而来，实际上 b2 有 1.5M 内存，只是指向了其中的 1M 内存。

Java 内存分配