当前位置: 首页 > article >正文

说说JVM的底层原理(JAVA是如何运行的)?


JVM 底层原理深度解析

Java 虚拟机(JVM)是 Java 程序运行的核心环境,其设计融合了内存管理、类加载、垃圾回收和高效执行等复杂机制。以下从底层视角详细解析其核心模块,并结合实际场景说明其工作原理。


一、类加载机制

1. 类加载的触发与过程

类加载是 JVM 动态性的基石,其触发条件包括首次使用类(如 new、反射调用等)或继承父类时。整个过程分为三个阶段:

  1. 加载(Loading)

    • 功能:将 .class 字节码文件加载到内存,生成 Class 对象。
    • 实现细节
      • 类加载器(ClassLoader)通过全限定名查找 .class 文件。
      • 支持从文件系统、JAR 包、网络等来源加载。
    • 示例
      // 用户调用 new UserService() 时,触发 UserService.class 的加载
      UserService user = new UserService();
      
  2. 链接(Linking)

    • 验证(Verification):确保字节码符合 JVM 规范,防止恶意代码注入。
      • 文件格式验证:检查魔数(0xCAFEBABE)、版本号等。
      • 元数据验证:检查继承关系(如是否实现抽象方法)、字段类型等。
    • 准备(Preparation):为静态变量分配内存并赋零值。
      • 示例public static int count; 在准备阶段初始化为 0
      • 常量特殊处理public static final int MAX = 100; 直接赋值为 100
    • 解析(Resolution):将符号引用(如类名、方法名)转换为直接引用(内存地址)。
      • 示例:将 System.out.println 解析为实际的方法地址。
  3. 初始化(Initialization)

    • 执行 <clinit> 方法,合并所有静态代码块和静态变量赋值,按代码顺序执行。
    • 父类优先原则:若父类未初始化,先触发父类的初始化。
    • 示例
      static {
          System.out.println("静态代码块执行");
      }
      
2. 双亲委派模型
  • 核心思想:类加载请求优先委派父加载器处理,避免重复加载和核心类篡改。
  • 加载器层级
    • Bootstrap ClassLoader:加载 jre/lib 下的核心类(如 java.lang.*)。
    • Extension ClassLoader:加载 jre/lib/ext 下的扩展类。
    • Application ClassLoader:加载用户类路径(-classpath)的类。
    • 自定义 ClassLoader:用户扩展的加载器(如 Tomcat 的 WebappClassLoader)。
  • 破坏场景
    • SPI 机制:JDBC 驱动加载需使用线程上下文类加载器(ThreadContextClassLoader)。
    • 热部署:通过自定义类加载器实现类的动态替换。

二、内存管理

1. 内存区域划分

JVM 内存划分为多个区域,各司其职:

  1. 堆(Heap)

    • 功能:存储对象实例和数组,所有线程共享。
    • 分区
      • 新生代(Young Generation):新对象分配区,分 Eden、Survivor0、Survivor1。
      • 老年代(Old Generation):长期存活对象区。
    • 内存分配策略
      • 指针碰撞(堆内存规整时)或 空闲列表(内存碎片化时)。
      • TLAB(Thread Local Allocation Buffer):为每个线程预分配内存,避免竞争。
    • 示例
      Object obj = new Object(); // 对象分配在堆中
      
  2. 虚拟机栈(JVM Stack)

    • 功能:存储方法调用的栈帧(局部变量表、操作数栈、动态链接、方法出口)。
    • 栈帧结构
      • 局部变量表:存放方法参数和局部变量。
      • 操作数栈:执行字节码指令的工作区。
      • 动态链接:指向方法区的方法引用。
    • 示例
      public void calculate() {
          int a = 1;  // 存入局部变量表
          int b = 2;
          int c = a + b; // 操作数栈执行加法
      }
      
  3. 方法区(Method Area)

    • 功能:存储类信息、常量、静态变量。
    • 实现演变
      • JDK 7 及之前:永久代(PermGen),固定大小易导致 OutOfMemoryError
      • JDK 8+:元空间(Metaspace),使用本地内存,动态扩展。
    • 示例
      public static final String NAME = "JVM"; // 常量池存储在方法区
      
  4. 程序计数器(Program Counter Register)

    • 功能:记录当前线程执行的字节码指令地址(线程私有)。
    • 意义:线程切换后能恢复到正确执行位置。
2. 对象生命周期
  1. 创建

    • 类加载检查分配内存初始化零值设置对象头执行构造方法
    • 对象头结构
      • Mark Word:存储哈希码、GC 分代年龄、锁状态等。
      • 类型指针:指向类元数据(方法区中的 Class 对象)。
    • 示例
      User user = new User(); // 触发对象创建流程
      
  2. 内存回收

    • 对象不再被引用时,由垃圾回收器回收内存。

三、垃圾回收(GC)

1. 对象存活判定
  • 引用计数法:循环引用问题(Java 未采用)。
  • 可达性分析(主流):从 GC Roots 出发,标记不可达对象为垃圾。
    • GC Roots 包括
      • 虚拟机栈中引用的对象(局部变量)。
      • 方法区中静态变量、常量引用的对象。
      • JNI(Native 方法)引用的对象。
2. 垃圾回收算法
  1. 标记-清除(Mark-Sweep)

    • 流程:标记垃圾对象 → 清除。
    • 缺点:内存碎片化。
    • 应用场景:CMS 收集器的老年代回收。
  2. 复制(Copying)

    • 流程:将存活对象从 Eden 复制到 Survivor 区。
    • 优点:无碎片,适合存活率低的新生代。
    • 内存划分:Eden(80%)、Survivor0(10%)、Survivor1(10%)。
  3. 标记-整理(Mark-Compact)

    • 流程:标记存活对象 → 整理到内存一端 → 清除边界外内存。
    • 优点:无碎片,适合老年代。
    • 应用场景:Serial Old、G1 收集器。
  4. 分代收集(Generational)

    • 策略:新生代用复制算法,老年代用标记-清除或标记-整理。
    • 依据:对象存活周期不同(新生代对象生命周期短)。
3. 垃圾收集器
收集器特点适用场景
Serial单线程,简单高效客户端应用
Parallel Scavenge多线程,吞吐量优先后台计算任务
CMS低延迟,标记-清除,有内存碎片Web 应用
G1分 Region 管理,可预测停顿时间大内存应用
ZGC超低延迟(<10ms),支持 TB 级堆高并发实时系统

四、执行引擎

1. 解释器与 JIT 编译器
  • 解释器:逐行解释字节码,启动快但执行慢。
  • JIT 编译器(Just-In-Time):将热点代码编译为本地机器码,提升执行速度。
    • 热点探测:基于方法调用计数器、循环回边计数器。
    • 优化技术
      • 方法内联:将小方法调用替换为方法体代码。
      • 逃逸分析:若对象未逃逸出方法,直接在栈上分配。
      • 锁消除:移除线程安全的无竞争锁。
2. 分层编译(Tiered Compilation)
  • 层级
    • Level 0:解释执行。
    • Level 1:简单编译(C1 编译器,快速生成代码)。
    • Level 4:完全优化(C2 编译器,深度优化,耗时长)。
  • 目标:平衡启动速度和长期性能。

五、实战场景分析

1. Spring Boot 启动流程中的 JVM 行为
@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args); // 触发类加载、Bean 初始化
    }
}

@Service
public class UserService {
    static { System.out.println("静态代码块执行"); }
    public UserService() { System.out.println("构造方法执行"); }
}

输出

静态代码块执行  // 类初始化阶段
构造方法执行    // Bean 实例化阶段
  • 类加载:Spring 扫描到 @Service 注解时触发 UserService 类加载。
  • Bean 实例化:Spring 容器启动时创建单例 Bean,调用构造方法。
2. 内存泄漏排查

场景:静态集合持有对象导致无法回收。

public class MemoryLeak {
    private static List<byte[]> list = new ArrayList<>();
    public void addData() {
        list.add(new byte[1024 * 1024]); // 持续添加大对象
    }
}

排查步骤

  1. 使用 jps 查看 Java 进程 ID。
  2. 使用 jmap -dump:format=b,file=heap.hprof <pid> 生成堆转储文件。
  3. 使用 MAT(Memory Analyzer Tool) 分析 list 的引用链,定位泄漏点。

六、JVM 调优策略

1. 堆内存设置
  • 参数
    • -Xms:初始堆大小(如 -Xms512m)。
    • -Xmx:最大堆大小(如 -Xmx2g)。
  • 建议-Xms-Xmx 设为相同值,避免堆动态调整的开销。
2. 垃圾收集器选择
  • 高吞吐量-XX:+UseParallelGC(Parallel Scavenge + Parallel Old)。
  • 低延迟-XX:+UseG1GC(G1 收集器)或 -XX:+UseZGC(ZGC)。
3. 监控工具
  • jstat:监控 GC 统计信息。
    jstat -gcutil <pid> 1000  # 每秒输出一次 GC 统计
    
  • VisualVM:图形化监控堆、线程、CPU。
  • Arthas:在线诊断工具,支持方法调用追踪、热修复。

七、总结

JVM 的底层原理是 Java 生态高效运行的基石:

  1. 类加载:动态加载与安全隔离。
  2. 内存管理:堆与栈的分工,对象生命周期的精准控制。
  3. 垃圾回收:自动内存管理的核心,影响系统吞吐量与延迟。
  4. 执行引擎:解释与编译结合,实现高性能执行。

深入理解 JVM,不仅能优化应用性能(如减少 Full GC 停顿),还能有效排查内存泄漏、锁竞争等问题,是高级 Java 开发的必备技能。


http://www.kler.cn/a/566737.html

相关文章:

  • Redisson 分布式锁底层原理实现详解
  • FC兵蜂2游戏技巧
  • 学习路程七 langchain核心组件 Prompt
  • AI绘画软件Stable Diffusion详解教程(2):Windows系统本地化部署操作方法(专业版)
  • MOM成功实施分享(七)电力电容制造MOM工艺分析与解决方案(第一部分)
  • 基于 Python 的天气数据分析与可视化
  • 《深度学习实战》第4集:Transformer 架构与自然语言处理(NLP)
  • Python 爬虫与网络安全有什么关系
  • 进程状态(R|S|D|t|T|X|Z)、僵尸进程及孤儿进程
  • 自动化办公|xlwings与pandas交互
  • flex布局自定义一行几栏,靠左对齐===grid布局
  • react工程化开发
  • TCP/IP 5层协议簇:网络层(IP数据包的格式、路由器原理)
  • 滑动验证组件-微信小程序
  • Nginx系列06(Nginx 缓存配置、SSL/TLS 配置)
  • 使用 pytest-mock 进行 Python 高级单元测试与模拟
  • Vue 路由基础:Vue 2 和 Vue 3 的比较与使用
  • openinstall支持鸿蒙App Linking:赋能系统级深度链接能力
  • UniApp 使用 u-loadmore 完整步骤
  • Elasticsearch:过滤 HNSW 搜索,快速模式