Java内存分析

Java内存可以大概分为堆，栈，方法区

堆：

1. 存放new出来的对象和数组
2. 可以被所有的线程共享，不会存放别的对象引用

栈：

1. 存放基本变量类型（会包含这个基本类型的具体数值）
2. 引用对象的变量（会存放这个引用对象在堆里面的具体地址）

方法区：

1. 可以被所有的线程共享
2. 包含了所有的class和static变量

类加载时内存分析

1）加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象到堆中。

2）链接：链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。

• 验证:确保加载的类信息符合JVM规范，没有安全方面的问题
• 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
• 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

3）初始化:

• 执行类构造器(方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)

• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

• 虚拟机会保证一个类的 <clinit>() 方法在多线程环境中被正确加锁和同步。<clinit>() 方法是类初始化方法（class initializer），它由编译器生成，用于执行类的静态初始化块和静态变量的赋值。如果一个类没有静态初始化块或者静态变量，编译器就不会为这个类生成 方法。

用下面代码来讲解类的加载过程：

class A {
    static int m = 100;
    static {
        System.out.println("A类静态代码初始化");
        m = 300;
    }

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

class TTTT {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
    }
}

类加载过程

类加载过程分为三个阶段：加载、链接和初始化。

1. 加载（Loading）

• 加载：将 A.class 和 TTTT.class 文件的字节码内容加载到内存中。但此时，这些数据结构还未完全准备好，因为静态变量的内存分配和初始值设置是在链接阶段的准备（Preparation）子阶段中完成的。
• 方法区：在方法区中生成 A 类和 TTTT 类的运行时数据结构。
• 堆：在堆中生成一个代表 A 类和 TTTT 类的 java.lang.Class 对象，这些 Class 对象指向方法区的类元数据。

链接（Linking）

链接包括验证、准备和解析三个子阶段。

验证：

确保类文件格式正确，并且字节码符合 JVM 规范。

准备：

为类的静态变量分配内存并设置默认初始值。例如，static int m 被初始化为 0。此时，方法区中的类数据结构会包含静态变量的内存分配和初始值。

解析：

将常量池中的符号引用替换为直接引用。符号引用是对类、方法、字段等的名称引用，而直接引用是实际的内存地址或方法指针。当 JVM 执行方法时，方法字节码会引用常量池中的符号。

内存示意图
在链接阶段的准备子阶段之后，我们可以生成如下的内存示意图：

|-----------------------------------------------------------|
| 类名: A                                                   |
| 父类: java.lang.Object                                    |
| 接口: 无                                                  |
| 字段: static int m                                        |
| 方法: <clinit>(), A()                                     |
| 静态变量: static int m，初始值为 0                        |
| 常量池:                                                   |
|   - 字面量:                                               |
|       - 100 (整数)                                        |
|       - "A类静态代码初始化" (字符串)                       |
|   - 符号引用:                                             |
|       - 类引用: java/lang/Object (解析为直接引用)         |
|       - 字段引用: m (解析为内存地址)                      |
|       - 方法引用: <clinit>() (解析为方法指针)             |
|       - 方法引用: A() (解析为方法指针)                    |
| 方法字节码: <clinit>(), A()                               |
|-----------------------------------------------------------|
| 类名: TTTT                                                |
| 父类: java.lang.Object                                    |
| 接口: 无                                                  |
| 字段: 无                                                  |
| 方法: main(String[] args)                                 |
| 常量池:                                                   |
|   - 字面量:                                               |
|       - "A类静态代码初始化" (字符串)                       |
|   - 符号引用:                                             |
|       - 类引用: A (解析为直接引用)                        |
|       - 方法引用: main([Ljava/lang/String;)V (解析为方法指针) |
|       - 方法引用: A() (解析为方法指针)                    |
|       - 字段引用: m (解析为内存地址)                      |
| 方法字节码: main(String[] args)                           |
|-----------------------------------------------------------|

初始化（Initialization）

执行类构造器 方法：

执行类构造器(方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)

对 A 类：

将 static int m 赋值为 100。
执行静态代码块：

static {
    System.out.println("A类静态代码初始化");
    m = 300;
}

输出 A类静态代码初始化。
将 m 赋值为 300。

对 TTTT 类：

没有静态变量和静态代码块需要初始化，因此直接完成初始化。

---

开始运行main方法：

class TTTT {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
    }
}

内存布局

方法区

类元数据：
A 类：包含类名、父类信息、字段 static int m、方法（构造方法、静态代码块）信息。
TTTT 类：包含类名、父类信息、方法 main(String[] args) 信息。
运行时常量池：
存储符号引用，如类名、方法名、字段名等。
静态变量：
A 类的 static int m，最终值为 300。
方法字节码：
A 类的构造方法、静态代码块。
TTTT 类的 main(String[] args) 方法。

堆

Class 对象：
一个表示 A 类的 java.lang.Class 对象。
一个表示 TTTT 类的 java.lang.Class 对象。

实例对象：
A 类的实例对象，创建时调用了 A 类的构造方法，输出 A类的无参构造初始化。

栈

main 方法栈帧，执行完main方法就弹出该栈帧：
局部变量表：存储 args 和 a。
操作数栈：用于方法调用和返回值。

构造方法栈帧，执行完构造方法就弹出该栈帧：
局部变量表：存储 this。
操作数栈：用于构造方法的执行。