架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

JVM:内存布局、类加载与调优

2020年3月1日 #后端开发 #Java

本章是整理知识内容,为强化知识长期更新。

JVM

JVM 全称 Java Virtual Machine,也就是我们耳熟能详的 Java 虚拟机。JVM 会翻译执行 Java 字节码,然后调用真正的操作系统函数,这些操作系统函数是与平台息息相关的。

  • 如上图所示,通过JVM,Java实现了跨平台、只要class文件能正常执行,就可以在其他系统上面运行。 JVM 与操作系统之间的关系:JVM 上承开发语言,下接操作系统,它的中间接口就是字节码。

JDK

  • JDK 的全拼,Java Development Kit JVM、JRE、JDK 它们三者之间的关系,可以用一个包含关系表示。

JVM字节码

对于 Java 开发者来说,虚拟机、字节码就是其底层知识。Java Byte 由单字节 byte的指令组成,理论上最多支持256个操作码。实际上只使用了200个左右操作码。

编译java文件

这里采用xxd xx.java


package cn.z201.jvm;

public class Testing {

    public static void main(String[] args){
        System.out.println("Hello world!");
    }
}
  • 通过javac编译成class文件、在用xxd查看编译后的16进制class文件。
➜  jvm git:(master) ✗ javac Testing.java 
➜  jvm git:(master) ✗ xxd Testing.class 
00000000: cafe babe 0000 0034 001d 0a00 0600 0f09  .......4........
00000010: 0010 0011 0800 120a 0013 0014 0700 1507  ................
00000020: 0016 0100 063c 696e 6974 3e01 0003 2829  .....<init>...()
00000030: 5601 0004 436f 6465 0100 0f4c 696e 654e  V...Code...LineN
00000040: 756d 6265 7254 6162 6c65 0100 046d 6169  umberTable...mai
00000050: 6e01 0016 285b 4c6a 6176 612f 6c61 6e67  n...([Ljava/lang
00000060: 2f53 7472 696e 673b 2956 0100 0a53 6f75  /String;)V...Sou
00000070: 7263 6546 696c 6501 000c 5465 7374 696e  rceFile...Testin
00000080: 672e 6a61 7661 0c00 0700 0807 0017 0c00  g.java..........
00000090: 1800 1901 000c 4865 6c6c 6f20 776f 726c  ......Hello worl
000000a0: 6421 0700 1a0c 001b 001c 0100 1363 6e2f  d!...........cn/
000000b0: 7a32 3031 2f6a 766d 2f54 6573 7469 6e67  z201/jvm/Testing
000000c0: 0100 106a 6176 612f 6c61 6e67 2f4f 626a  ...java/lang/Obj
000000d0: 6563 7401 0010 6a61 7661 2f6c 616e 672f  ect...java/lang/
000000e0: 5379 7374 656d 0100 036f 7574 0100 154c  System...out...L
000000f0: 6a61 7661 2f69 6f2f 5072 696e 7453 7472  java/io/PrintStr
00000100: 6561 6d3b 0100 136a 6176 612f 696f 2f50  eam;...java/io/P
00000110: 7269 6e74 5374 7265 616d 0100 0770 7269  rintStream...pri
00000120: 6e74 6c6e 0100 1528 4c6a 6176 612f 6c61  ntln...(Ljava/la
00000130: 6e67 2f53 7472 696e 673b 2956 0021 0005  ng/String;)V.!..
00000140: 0006 0000 0000 0002 0001 0007 0008 0001  ................
00000150: 0009 0000 001d 0001 0001 0000 0005 2ab7  ..............*.
00000160: 0001 b100 0000 0100 0a00 0000 0600 0100  ................
00000170: 0000 0500 0900 0b00 0c00 0100 0900 0000  ................
00000180: 2500 0200 0100 0000 09b2 0002 1203 b600  %...............
00000190: 04b1 0000 0001 000a 0000 000a 0002 0000  ................
000001a0: 0008 0008 0009 0001 000d 0000 0002 000e  ................


  • 编译后完全看不懂,jdk实际上提供了专门用来解析类文件的工具javap

javap

javap能对给定的class文件提供的字节代码进行反编译

  • 使用格式
javap <options> <classes>

  -help  --help  -?        输出此用法消息
  -version                 版本信息
  -v  -verbose             输出附加信息
  -l                       输出行号和本地变量表
  -public                  仅显示公共类和成员
  -protected               显示受保护的/公共类和成员
  -package                 显示程序包/受保护的/公共类
                           和成员 (默认)
  -p  -private             显示所有类和成员
  -c                       对代码进行反汇编
  -s                       输出内部类型签名
  -sysinfo                 显示正在处理的类的
                           系统信息 (路径, 大小, 日期, MD5 散列)
  -constants               显示最终常量
  -classpath <path>        指定查找用户类文件的位置
  -cp <path>               指定查找用户类文件的位置
  -bootclasspath <path>    覆盖引导类文件的位置
  • 演示下上面的类
javap -c -s -v Testing

Classfile /Users/z201/word/z201.github.io.code/java-learning/learn-jvm/src/test/java/cn/z201/jvm/Testing.class
  MD5 checksum b50deb6f6e7df9bb99585bc71b92d39b
  Compiled from "Testing.java"
public class cn.z201.jvm.Testing
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // Hello world!
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // cn/z201/jvm/Testing
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               Testing.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               Hello world!
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               cn/z201/jvm/Testing
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public cn.z201.jvm.Testing();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 5: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello world!
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 8: 0
        line 9: 8
}
SourceFile: "Testing.java"

IDEA bytecode viewer

jclasslib is a bytecode viewer for Java class files

  • 在plugins中搜索jclasslib bytecode viewer
  • 安装重启IDEA后,编译项目代码(run 一次)选中代码文件 view 菜单中有 bytecode viewer 选项。

  • IDEA 显示的内容更加容易阅读。

JVM的内存布局

堆

  • 堆(Java Heap) 也叫 Java 堆或者是 GC 堆,它是一个线程共享的内存区域,也是 JVM 中占用内存最大的一块区域,Java 中所有的对象都存储在这里。

    • 存储的是我们new来的对象,不存放基本类型和对象引用。

    • 由于创建了大量的对象,垃圾回收器主要工作在这块区域。

    • 线程共享区域,因此是线程不安全的。

    • 能够发生内存溢出,主要有OutOfMemoryError和StackOverflowError。

    • 那么什么时候发生OutOfMemoryError,什么时候发生StackOverflowError?虚拟机在扩展栈时无法申请到足够的内存空间,将抛出OutOfMemoryError异常,线程请求的栈深度超过虚拟机所允许的最大深度,将抛出StackOverflowError异常。

    • Java堆区还可以划分为新生代和老年代,新生代又可以进一步划分为Eden区、Survivor 1区、Survivor 2区。具体比例参数的话,可以看一下下面这张图。

    • 合理设置老年代和新生代的空间比例对 JVM 垃圾回收的性能有很大影响,JVM 设置老年代新生代比例的参数是 -XX:NewRatio。
  • Minor GC 发生在新生代,而 Full GC 发生在老年代。

  • 大部分新生成的对象都是在 Eden 区,Eden 区满了之后便没有内存给新对象使用,Eden 区便会 Minor GC 回收无用内存,剩下的存活对象便会转移到 Survivor 区。

  • 从 Eden 区存活下来的对象首先会被复制到 From 区,当 From 区满时,此时还存活的对象会被转移到 To 区,经历了多次的 Minor GC 后,还存活的对象就会被复制到老年代,老年代的 GC 一般叫作 FullGC 或者 MajorGC。

新生代

  • 新生代是类的诞生、成长、消亡的区域,一个类在这里产生、应用,最后被垃圾回收器收集,结束生命。新生区又分为两部分:伊甸区(Eden space)和幸存区(Survivor pace),绝大多数的类都是在伊甸区被 new 出来的。幸存区有两个:0区(from Survivor 0 space)和 1区(to Survivor 1 space)。两个Survivor 区空间一样大,当Eden 区满了,则会触发普通GC,若 Eden 区中的对象经过垃圾回收没有被回收掉,会将Eden 区中的幸存对象移动到幸存0区。若幸存0区也满了,再对该区域进行垃圾回收,然后移动到1区,然后之前的0区将置为空,没有任何数据。显然,Survivor 区只是增加了对象在年轻代中逗留的时间,增加了被垃圾回收的可能性。那如果1区也满了呢?再移动到养老区。若养老区也满了,那么这时候将产生Full GC,进行养老区的内存清理。若养老区执行Full GC 之后发现依然无法进行对象的保存,就会产生 OOM 异常“OutOfMemoryError”。
  • 每次垃圾回收时都有大量的对象需要被回收。垃圾回收器在新生代采用的收集算法是Copying(复制)方法:它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当这一块面对内存用完了,就将还存活的对象复制到另外一块,然后再把已使用的内存空间一次清理掉。由于新生代有每次垃圾回收时都有大量的对象需要被回收的特点,所以采用Copying算法,复制的存活对象较少,性能比较好。但是Copying算法还是有缺陷的,那就是内存的使用率只有一半。

OutOfMemoryError

 java.lang.OutOfMemoryError: Java heap space
  • Java 虚拟机的堆内存设置不够,可以通过-Xms、-Xmx来调整

  • 代码中创建了大量大对象,并且长时间不能被垃圾回收器收集

  • 内存加载的数据量太大:一次性从数据库取太多数据

  • 集合类中有对对象的引用,使用后未清空,GC不能进行回收

  • 代码中存在循环产生过多的重复对象

老年代

  • 年轻代中经过垃圾回收没有回收掉的对象将被Copy到年老代。
  • 每次垃圾回收时只有少量的对象需要被回收。垃圾回收器在老年代采用的收集算法是 Mark-Compact 算法:为了解决Copying算法的缺陷,充分利用内存空间,提出了Mark-Compact算法。它先将需要回收的对象进行标记,然后将存活对象都向一端移动,然后清理掉端边界以外的内存。

FULL GC

  • 当老年代空间满了,就会对新生代和老年代空间进行一次全量垃圾回收,即Full GC。

方法区

  • 方法区(Method Area) 也被称为非堆区,用于和“Java 堆”的概念进行区分,它也是线程共享的内存区域,用于存储已经被 JVM 加载的类型信息、常量、静态变量、代码缓存等数据。

运行时常量池

  • Run-Time Constant Pool这是方法区的一部分,版本号、字段、方法、超类、接口等各种信息,还有一项信息就是常量池。Java 的常量池可以存放各种常量信息,不管是编译期生成的各种字面量,还是需要在运行时决定的符号引用。

程序计数器

  • 程序计数器(Program Counter Register) 线程独有一块很小的内存区域,保存当前线程所执行字节码的位置,包括正在执行的指令、跳转、分支、循环、异常处理等。

虚拟机栈

  • 虚拟机栈也叫 Java 虚拟机栈(Java Virtual Machine Stack),和程序计数器相同它也是线程独享的,用来描述 Java 方法的执行,在每个方法被执行时就会同步创建一个栈帧,用来存储局部变量表、操作栈、动态链接、方法出口等信息。当调用方法时执行入栈,而方法返回时执行出栈。
    • 线程私有区域,每一个线程都有独享一个虚拟机栈,因此这是线程安全的区域。

    • 存放基本数据类型以及对象的引用。

    • 每一个方法执行的时候会在虚拟机栈中创建一个相应栈帧,方法执行完毕后该栈帧就会被销毁。方法栈帧以先进后出的方式管理虚拟机栈。

    • 每一个栈帧又可以划分为局部变量表、操作数栈、动态链接、方法出口以及额外的附加信息。

      • 这个区域可能有两种异常:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常(通常是递归导致的);JVM动态扩展时无法申请到足够内存则抛出OutOfMemoryError异常。

本地方法栈

  • 本地方法栈(Native Method Stacks)与虚拟机栈类似,它是线程独享的,并且作用也和虚拟机栈类似。只不过虚拟机栈是为虚拟机中执行的 Java 方法服务的,而本地方法栈则是为虚拟机使用到的本地(Native)方法服务。

  • JVM 的执行流程是,首先先把 Java 代码(.java)转化成字节码(.class),然后通过类加载器将字节码加载到内存中,所谓的内存也就是我们上面介绍的运行时数据区,但字节码并不是可以直接交给操作系统执行的机器码,而是一套 JVM 的指令集。这个时候需要使用特定的命令解析器也就是我们俗称的**执行引擎(Execution Engine)**将字节码翻译成可以被底层操作系统执行的指令再去执行,这样就实现了整个 Java 程序的运行,这也是 JVM 的整体执行流程。

类的加载机制

符号引用和直接引用有一个重要的区别:使用符号引用时被引用的目标不一定已经加载到内存中;而使用直接引用时,引用的目标必定已经存在虚拟机的内存中了。

  • 类的生命周期会经历以下 7 个阶段:

  1. 加载阶段(Loading)
  2. 验证阶段(Verification)
  3. 准备阶段(Preparation)
  4. 解析阶段(Resolution)
  5. 初始化阶段(Initialization)
  6. 使用阶段(Using)
  7. 卸载阶段(Unloading)

加载阶段

此阶段用于查到相应的类(通过类名进行查找)并将此类的字节流转换为方法区运行时的数据结构,然后再在内存中生成一个能代表此类的 java.lang.Class 对象,作为其他数据访问的入口。

  • Java语言的类型可以分为两大类:基本类型、引用类型。基本类型是由虚拟机预先定义好的,所以不会经历单独的类加载过程。而引用类型又分为四种:类、接口、数组类、泛型参数。由于泛型参数会在编译的过程中被擦除(关于类型擦除的知识,大家可以查下资料),所以在Java中只有类、接口、数组类三种类型需要经历JVM对其进行连接和初始化的过程。

验证阶段

此步骤主要是为了验证字节码的安全性,如果不做安全校验的话可能会载入非安全或有错误的字节码,从而导致系统崩溃,它是 JVM 自我保护的一项重要举措。

  • 验证的主要动作大概有以下几个:
    • 文件格式校验包括常量池中的常量类型、Class 文件的各个部分是否被删除或被追加了其他信息等;
    • 元数据校验包括父类正确性校验(检查父类是否有被 final 修饰)、抽象类校验等;
    • 字节码校验,此步骤最为关键和复杂,主要用于校验程序中的语义是否合法且符合逻辑;
    • 符号引用校验,对类自身以外比如常量池中的各种符号引用的信息进行匹配性校验。

准备阶段

此阶段是用来初始化并为类中定义的静态变量分配内存的,这些静态变量会被分配到方法区上。这些变量所使用的内存都将在方法区(<Jdk1.8)元数据区(>=Jdk1.8)中进行分配。这时候进行内存分配的仅包括类变量,而不包括实例变量,实例变量将会在对象实例化的时候随对象一起分配在Java堆中。

解析阶段

此阶段主要是用来解析类、接口、字段及方法的,解析时会把符号引用替换成直接引用。

  • 所谓的符号引用是指以一组符号来描述所引用的目标,符号可以是任何形式的字面量,只要使用时能无歧义地定位到目标即可;而直接引用是可以直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄。

  • 符号引用和直接引用有一个重要的区别:使用符号引用时被引用的目标不一定已经加载到内存中;而使用直接引用时,引用的目标必定已经存在虚拟机的内存中了。

初始化

初始化阶段 JVM 就正式开始执行类中编写的 Java 业务代码了。到这一步骤之后,类的加载过程就算正式完成了。

  • JVM 规范枚举了下述多种触发情况:
    • 当虚拟机启动时,初始化用户指定的主类;
      • 当遇到用以新建目标类实例的 new 指令时,初始化 new 指令的目标类;
      • 当遇到调用静态方法的指令时,初始化该静态方法所在的类;
      • 当遇到访问静态字段的指令时,初始化该静态字段所在的类;子类的初始化会触发父类的初始化;
      • 如果一个接口定义了 default 方法,那么直接实现或者间接实现该接口的类的初始化,会触发该接口的初始化;
      • 使用反射 API 对某个类进行反射调用时,初始化这个类;
      • 当初次调用 MethodHandle 实例时,初始化该 MethodHandle 指向的方法所在的类。

Jvm垃圾回收

  • JVM可以自动管理内存,拥有自动垃圾回收机制,主要是对堆中的对象进行清理。

可达性分析算法

从线程栈帧中局部变量或者方法区的静态变量引用的对象进行标记,然后判断被标记的对象是否引用了其他对象,通过持续标记。找出未被标记的对象,这些对象就是可以被回收的垃圾对象。

回收方式

清理

  • 将垃圾对象占用用的空间标记成空闲,记录在空闲队列中,当需要分配新对象的时候,就从空闲队列中找到合适的空间分配给这个对象。但是垃圾对象是散落在内存空间各处,并不是连续存放的。当需要分配一段连续大的内存空间的时候,可能出现没有足够空闲空间的问题。

压缩

  • 从堆空间的头部开始,将存活的对象拷贝在一段连续的内存空间中,剩余的空间就是连续的空闲空间。

复制

  • 将堆空间拆分成2空间from、to,其中一部分创建对象,当from空间对象使用完成后,将标记过的对象复制到to空间中,当对象从from复制到to空间后,两个空间交换引用,继续在from空间创建对象,一直到from空间满了。这里的空闲是指标记空闲。

垃圾回收器

具体执行垃圾回收的回收器有四种,

Serial

  • 早期的垃圾回收器只有一个线程执行垃圾回收。

Parallel

  • 多个线程执行垃圾回收,适合在多核cpu上面,在串行或者并行垃圾回收过程中,需要停止用户程序线程,或者可能导致对象标记错乱。对用户程序影响较大,程序都停止了。

CMS

  • 在垃圾回收的阶段,垃圾回收器和用户线程可以并发执行,对程序线程影响较小。

G1

  • 将堆拆分成多个子区域,每个区域独自进行垃圾回收。整个过程垃圾回收线程和用户程序线程并行。效率较高适合多种场景。

类加载器

虚拟机设计团队把加载动作放到 JVM 外部实现,以便让应用程序决定如何获取所需的类,JVM 提供了 3 种类加载器:

  • BootstrapClassloader 启动(根)类加载器

    • 它不是java类,该类加载器由C++实现,它嵌套在JVM内核里,当JVM启动时该类加载器就启动了。负责加载Java基础类,对应加载的文件是JRE/lib/ 目录下的rt.jar、resources.jar、charsets.jar等。
  • ExtensionClassLoader 扩展类加载器

    • 加载JRE/lib/ext下面指定要用的jar包,继承URLClassLoader。
  • AppClassLoader 应用程序类加载器

    • 加载应用程序classpath目录下的所指定的类库,继承URLClassLoader。
  • 自上而下尝试加载,最下面的加载器没有加载到的话,则抛出ClassNotFoundException。

    • 如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行;
    • 如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器;
    • 如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,

双亲委派机制

  • 这种工作原理就是双亲委派机制。Java类随着加载它的类加载器一起具备了一种带有优先级的层次关系。比如,Java中的Object类,它存放在rt.jar之中,无论哪一个类加载器要加载这个类,最终都是委派给处于模型最顶端的启动类加载器进行加载,因此Object在各种类加载环境中都是同一个类。如果不采用双亲委派模型,那么由各个类加载器自己去加载的话,那么系统中会存在多种不同的Object类。
    • 避免核心API被篡改。
    • 避免类的重复加载。
  • 子类加载器可以访问父加载器的类型,但是反过来不行。由于父加载器的类型对于子加载器是可见的,所以父加载器中加载的类型不会在子加载器中重复加载。

负责依赖

  • 如果一个加载器在加载某个类的时候,发现这个类依赖于另外几个类或接口,也会去尝试加载这些依赖项。

缓存加载

  • 为了提升加载效率,消除重复加载,一旦某个类被一个类加载器加载,那么它会缓存这个加载结果,不会重复加载。

JVM 调优

默认参数无法发挥程序性能时才需要调优:调优的目标是在更少的内存与停顿下获得更高吞吐。

什么时候需要调优

  • 堆内存(老年代)持续上涨,达到设置的最大值。
  • Full GC 次数频繁。
  • GC 停顿时间过长,超过 1 秒。
  • 应用出现 OutOfMemory 等内存异常。
  • 应用中使用本地缓存且占用大量内存。
  • 系统吞吐量与响应性能不高或持续下降。

调优顺序

  • 上线前先把 JVM 启动参数设置到合适值。
  • 大多数 GC 问题源于代码:减少创建对象、减少全局变量与大对象。
  • 优先做架构调优和代码调优,JVM 参数是最后手段。
  • 分析 GC 情况后优化代码,比直接调 JVM 参数更有效。

启动参数

调优的最终目的是让应用用最小的硬件消耗承载更大的吞吐量:

  • 延迟:GC 低停顿、低频率。
  • 低内存占用。
  • 高吞吐量。
  • 堆内存 = Old + Eden + S0 + S1;新生代 = Eden + S0 + S1。

JVM 参数分三类:

  • 标准参数(-):所有 JVM 实现都必须支持,向后兼容。
  • 非标准参数(-X):默认实现支持,但不保证所有 JVM 实现都满足,也不保证向后兼容。
  • 非稳定参数(-XX):各 JVM 实现可能不同,未来可能不再支持,使用需谨慎。

一组常见配置:

-XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m -Xms1024m -Xmx1024m -Xmn256m -Xss256k -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC

各参数含义:

-XX:MetaspaceSize=128m (元空间初始大小)
-XX:MaxMetaspaceSize=128m (元空间最大大小)
-Xms1024m (堆初始大小)
-Xmx1024m (堆最大大小)
-Xmn256m (新生代大小)
-Xss256k (栈最大深度大小)
-XX:SurvivorRatio=8 (新生代分区比例 8:2)
-XX:+UseConcMarkSweepGC (指定垃圾收集器,这里使用 CMS)
-XX:+PrintGCDetails (打印详细 GC 日志)

调优的参考线:堆内存使用率不超过 70%,老年代使用率不超过 70%,单次 GC 平均停顿不超过 1 秒,Full GC 次数为 0 或间隔不少于 24 小时。

  • 建议 -Xms 取最大内存的 0.6 至 0.8 倍,并留出系统自身的内存开销。
  • 堆内存必须是 1024 的倍数,且不低于 2 MB;32 位机器上限约 1 GB,64 位机器可以更大。
  • 堆外内存一般指 Direct Memory,不受 GC 控制,JVM 与 Netty 都可能使用,可用 -XX:MaxDirectMemorySize 限制。

当不确定某个参数的含义时,可以输出当前 JVM 支持的全部参数:

java -XX:+PrintFlagsFinal -XX:+UnlockDiagnosticVMOptions -version | wc -l
openjdk version "1.8.0_275"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_275-b01)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.275-b01, mixed mode)
     838

内存分配与 GC 的关系

  • 在特定业务场景下,内存分配不合理带来的性能损耗不像内存溢出那样明显,不深入指标很难发现。
  • 最直接的表现是频繁 GC,进而引发上下文切换,降低吞吐量、拉长响应时间。

分析 GC 日志

压测时需要同时开启 GC 日志:

-XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:/log/heap.log
  • -XX:+PrintGCTimeStamps:打印 GC 发生的具体时间。
  • -XX:+PrintGCDetails:打印 GC 详细日志。
  • -Xloggc:path:指定 GC 日志文件路径。

JVM 内存调优与 GC 调优互补,在确定堆与新生代大小后,再针对垃圾回收算法继续调整。

扩展

你将如何使用thread dump?你将如何分析Thread dump

  • 线程转储是一个JVM活动线程的列表,它对于分析系统瓶颈和死锁非常有用。有很多方法可以获取线程转储——使用Profiler,Kill -3命令,jstack工具等等。我更喜欢jstack工具,因为它容易使用并且是JDK自带的。由于它是一个基于终端的工具,所以我们可以编写一些脚本去定时的产生线程转储以待分析。

Java中堆和栈有什么不同

  • 栈是⼀块和线程紧密相关的内存区域,每个线程都有⾃⼰的栈内存,⽤于存储本地变量,⽅法参数和栈调⽤,⼀个线程中存储的变量对其它线程是不可⻅的。
  • 堆是所有线程共享的⼀⽚公⽤内存区域,对象都在堆⾥创建,为了提升效率线程会从堆中弄⼀个缓存到⾃⼰的栈,如果多个线程使⽤该变量就可能引发问题,这时volatile 变量就可以发挥作⽤了,它要求线程从主存中读取变量的值。

内存泄漏和内存溢出

  • 内存溢出是说程序需要申请的内存超过了JVM当前可以分配的最大内存,溢出。
  • 内存泄漏是说期望被回收的内存对象没有被回收,泄漏。
  • 内存泄漏持续发生,很可能引起内存溢出。

查看GC频次

如果是JDK自带的工具,可以使用jstat查看GC频次。

小结

从 class 文件头与 javap 反汇编切入,讲堆、方法区、栈等区域、类加载七阶段与双亲委派;调优先改代码,再按 -Xms、-Xmx、-Xmn 配堆,压测时用 -Xloggc 分析 GC 日志。

最近更新: 2026/11/20 22:30
Contributors: 庆峰
Prev
钉钉告警:应用异常与实例上下线
Next
Git:rebase 合并多次提交