jvm中gc算法（过两年 JVM 可能就要被 GraalVM 替代了）

大家好 
  
  
  
  
  
  
 ，我是风筝 
  
  
  
  
  
  
 ，公众号「古时的风筝」

 


 


 


 


 


 


 
，专注于 Java技术 及周边生态              。

文章会收录在 JavaNewBee 中 
 
 
 
 
 
 
，更有 Java 后端知识图谱 
   
   
   
   
   
   
  ，从小白到大牛要走的路都在里面
 
  
 
  
 
  
 
  
 
  
 
  
 
  。

今天说一说 GraalVM













。

GraalVM 是 Oracle 大力发展和想要推广的新一代 JVM 
 

 

 

 

 

 

 
，目前很多框架都已经渐渐支持 GraalVM 了
 

 

 

 

 

 

 
，比如我们在用的 Spring 也已经推出了对 GraalVM 兼容的工具包了  
  
  
  
  
  
  
。

既然说的这么厉害              ，那么它到底是何方神圣呢 
  
  
  
  
  
  
 。

GraalVM 和 JVM 的关系

既然叫做VM 

 
 

 
 

 
 

 
 

 
 

 
 

 
，那肯定和 JVM 有关系的吧


 


 


 


 


 


 


 。JVM 全称 Java 虚拟机













，我们都知道                     ，Java 程序是运行在虚拟机上的 
 
 
 
 
 
 
 
 
 
 
 
 
 
，虚拟机提供 Java 运行时




















，支持解释执行和部分的（JIT）即时编译器              ，并且负责分配和管理 Java 运行所需的内存 
  
 
  
 
  
 
  
 
  
 
  
 
  
，我们所说的各种垃圾收集器都工作在 JVM 中 
 
 
 
 
 
 
。

比如 Oracle JDK              、OpenJDK 













，默认的 JVM 是 HotSpot 虚拟机 
  
  
  
  
  
  
 ，这是当前应用最广泛的一个虚拟机  
   
   
   
   
   
   
 。我们平时见到的各种将虚拟机的书籍
 
  
 
  
 
  
 
  
 
  
 
  
 
  、文章













、面试题 
  
  
  
  
  
  
 ，基本上都是说的 HotSpot 虚拟机

 

 

 

 

 

 

 。

除此之外

 


 


 


 


 


 


 
，还有一些商用 
 
 
 
 
 
 
，或者说小众的虚拟机存在 
   
   
   
   
   
   
  ，比如IBM 的J9 JVM
 

 

 

 

 

 

 
，商用的 Zing VM 等
 

 

 

 

 

 

 
。

那 GraalVM 是另一种 Java 虚拟机吗？

是
 

 

 

 

 

 

 
，又不全是              。

GraalVM 可以完全取代上面提到的那几种虚拟机              ，比如 HotSpot
 

 
 

 
 

 
 

 
 

 
 

 
 

 。把你之前运行在 HotSpot 上的代码直接平移到 GraalVM 上 

 
 

 
 

 
 

 
 

 
 

 
 

 
，不用做任何的改变













，甚至都感知不到                     ，项目可以完美的运行













。

但是 GraalVM 还有更广泛的用途 
 
 
 
 
 
 
 
 
 
 
 
 
 
，不仅支持 Java 语言




















，还支持其他语言                     。这些其他语言不仅包括嫡系的 JVM 系语言              ，例如 Kotlin  
  
  
  
  
  
  
、Scala 
  
 
  
 
  
 
  
 
  
 
  
 
  
，还包括例如 JavaScript 
  
  
  
  
  
  
 、Nodejs


 


 


 


 


 


 


 、Ruby 
 
 
 
 
 
 
、Python 等
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

GraalVM 的野心不止于此













，看上面的图 
  
  
  
  
  
  
 ，它的目的是搭建一个 Framework 
  
  
  
  
  
  
 ，最终的目标是想要支持任何一种语言

 


 


 


 


 


 


 
，无论哪种语言 
 
 
 
 
 
 
，可以共同跑在 GraalVM 上 
   
   
   
   
   
   
  ，不存在跨语言调用的壁垒




















。

GraalVM 和JDK有什么关系

Java 虚拟机都是内置在 JDK 中的
 

 

 

 

 

 

 
，比如Orcale JDK  
   
   
   
   
   
   
 、OpenJDK
 

 

 

 

 

 

 
，默认内置的都是 HotSpot 虚拟机              。

GraalVM 也是一种 JDK              ，一种高性能的 JDK
 
  
 
  
 
  
 
  
 
  
 
  
 
  。完全可以用它替代 OpenJDK

 

 

 

 

 

 

 、Orcale JDK













。

GraalVM 如何运行 Java 程序

说了半天 

 
 

 
 

 
 

 
 

 
 

 
 

 
，是不是还是不知道 GraalVM 到底是什么  
  
  
  
  
  
  
。

GraalVM - 还包含 Graal （JIT）即时编译器













，可以结合 HotSpot 使用

GraalVM – 是一种高性能 JDK                     ，旨在加速 Java 应用程序性能 
 
 
 
 
 
 
 
 
 
 
 
 
 
，同时消耗更少的资源 
  
  
  
  
  
  
 。

GraalVM - 是一种支持多语言混编的虚拟机程序




















，不仅可以运行 JVM 系列的语言              ，也可支持其他语言


 


 


 


 


 


 


 。

GraalVM 提供了两种方式来运行 Java 程序 
 
 
 
 
 
 
。

第一种：结合 HotSpot 使用

上面说了 
  
 
  
 
  
 
  
 
  
 
  
 
  
，GraalVM 包含 Graal （JIT）即时编译器













，自从 JDK 9u 版本之后 
  
  
  
  
  
  
 ，Orcale JDK 和 OpenJDK 就集成了 Graal 即时编译器  
   
   
   
   
   
   
 。我们知道 Java 既有解释运行也有即时编译

 

 

 

 

 

 

 。

当程序运行时 
  
  
  
  
  
  
 ，解释器首先发挥作用

 


 


 


 


 


 


 
，代码可以直接执行
 

 

 

 

 

 

 
。随着时间推移 
 
 
 
 
 
 
，即时编译器逐渐发挥作用 
   
   
   
   
   
   
  ，把越来越多的代码编译优化成本地代码
 

 

 

 

 

 

 
，来获取更高的执行效率              。即时编译器可以选择性地编译热点代码
 

 

 

 

 

 

 
，省去了很多编译时间              ，也节省很多的空间
 

 
 

 
 

 
 

 
 

 
 

 
 

 。比如多次执行的方法或者循环
 

 

 

 

 

 

 
、递归等













。

JDK 默认使用的是 C2 即时编译器 

 
 

 
 

 
 

 
 

 
 

 
 

 
，C2是用C++编写的                     。而使用下面的参数可以用 Graal 替换 C2
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

Graal 编译器是用 Java 实现的













，用 Java 实现自己的编译器




















。Graal 基于一些假设的条件                     ，采取更加激进的方式进行优化              。采用 Graal 编译器之后 
 
 
 
 
 
 
 
 
 
 
 
 
 
，对性能有会有一定的提升
 
  
 
  
 
  
 
  
 
  
 
  
 
  。

但是如果你还是在用 JDK8




















，那对不起了              ，GraalVM 的一切都用不了













。

第二种：AOT 编译本地可执行程序

这是 GraalVM 真正厉害的地方  
  
  
  
  
  
  
。

AOT 提前编译 
  
 
  
 
  
 
  
 
  
 
  
 
  
，是相对于即时编译而言的 
  
  
  
  
  
  
 。AOT在运行过程中耗费 CPU 资源来进行即时编译













，而程序也能够在启动的瞬间就达到理想的性能


 


 


 


 


 


 


 。例如 C 和 C++语言采用的是AOT静态编译 
  
  
  
  
  
  
 ，直接将代码转换成机器码执行 
 
 
 
 
 
 
。而 Java 一直采用的是解释 + 即时编译技术 
  
  
  
  
  
  
 ，大多数情况下 Java 即时编译的性能并不比静态编译差

 


 


 


 


 


 


 
，但是还是一直朝着 AOT 编译的方向努力  
   
   
   
   
   
   
 。

但是 Java 对于 AOT 来说有一些难点 
 
 
 
 
 
 
，比如类的动态加载和反射调用

 

 

 

 

 

 

 。

GraalVM 显然是已经克服了这些问题 
   
   
   
   
   
   
  ，使用 GraalVM 可以直接将 Java 代码编译成本地机器码形态的可执行程序
 

 

 

 

 

 

 
。

我们目前运行 Java 一定要安装 JDK 或者 JRE 对不对
 

 

 

 

 

 

 
，如果将程序直接编译成可执行程序
 

 

 

 

 

 

 
，就不用在服务器上安装 JDK 或 JRE 了              。那就是说运行 Java 代码其实也可以不用虚拟机了是吗？

GraalVM 的 AOT 编译实际上是借助了 SubstrateVM 编译框架              ，可以将 SubstrateVM 理解为一个内嵌精简版的 JVM 

 
 

 
 

 
 

 
 

 
 

 
 

 
，包含异常处理













，同步                     ，线程管理 
 
 
 
 
 
 
 
 
 
 
 
 
 
，内存管理（垃圾回收）和 JNI 等组件
 

 
 

 
 

 
 

 
 

 
 

 
 

 。

SubstrateVM 的启动时间非常短




















，内存开销非常少













。用这种方式编译出的 Java 程序的执行时间可与C语言持平                     。

下图是使用即时编译（JVM运行）与 AOT (原生可执行程序)两种方式的 CPU 和内存使用情况对比              ，可以看出来 
  
 
  
 
  
 
  
 
  
 
  
 
  
，AOT 方式下 CPU 和内存的使用都非常少
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

除了运行时占用的内存少之外













，用这种方式最终生成的可执行文件也非常小




















。这对于云端部署非常友好              。目前很多场景下都使用 Docker 容器的方式部署 
  
  
  
  
  
  
 ，打一个 Java 程序的镜像包要包含完整的 JVM 环境和编译好的 Jar 包
 
  
 
  
 
  
 
  
 
  
 
  
 
  。而AOT 方式可以最大限度的缩小 Docker 镜像的体积













。

缺点

好处多多 
  
  
  
  
  
  
 ，当然也有一些弊端  
  
  
  
  
  
  
。对于反射这种纯粹在运行时才能确定的部分

 


 


 


 


 


 


 
，不可能完全通过优化编译器解决 
 
 
 
 
 
 
，只能通过增加配置的方式解决 
  
  
  
  
  
  
 。麻烦是麻烦了一点 
   
   
   
   
   
   
  ，但是是可行的
 

 

 

 

 

 

 
，Spring Boot 2.7的版本已经支持原生镜像了
 

 

 

 

 

 

 
，Spring 这种非常依赖反射的框架都可以支撑              ，我们用起来也应该没问题


 


 


 


 


 


 


 。

GraalVM 如何支持多语言

要支持多语言 

 
 

 
 

 
 

 
 

 
 

 
 

 
，就要说到 GraalVM 中的另一个核心组件 Truffle 了 
 
 
 
 
 
 
。

Truffle 是一个用 Java 写就的语言实现框架  
   
   
   
   
   
   
 。基于 Truffle 的语言实现仅需用 Java 实现词法分析              、语法分析以及针对语法分析所生成的抽象语法树（Abstract Syntax Tree













，AST）的解释执行器                     ，便可以享用由 Truffle 提供的各项运行时优化

 

 

 

 

 

 

 。

就一个完整的 Truffle 语言实现而言 
 
 
 
 
 
 
 
 
 
 
 
 
 
，由于实现本身以及其所依赖的 Truffle 框架部分都是用 Java 实现的




















，因此它可以运行在任何 Java 虚拟机之上
 

 

 

 

 

 

 
。

当然              ，如果 Truffle 运行在附带了 Graal 编译器的 Java 虚拟机之上 
  
 
  
 
  
 
  
 
  
 
  
 
  
，那么它将调用 Graal 编译器所提供的 API













，主动触发对 Truffle 语言的即时编译 
  
  
  
  
  
  
 ，将对 AST 的解释执行转换为执行即时编译后的机器码              。

目前除了 Java 
  
  
  
  
  
  
 ， JavaScript
 

 
 

 
 

 
 

 
 

 
 

 
 

 、Ruby













、Python 和许多其他流行语言都已经可以运行在 GraalVM 之上了
 

 
 

 
 

 
 

 
 

 
 

 
 

 。

GraalVM 官方还提供了完整的文档

 


 


 


 


 


 


 
，当有一天你开发了一款新的语言 
 
 
 
 
 
 
，也可以用 Truffle 让它跑在 GraalVM 上













。

安装和使用

GraalVm 目前的最新版本是 22.3 
   
   
   
   
   
   
  ，分为社区版和企业版
 

 

 

 

 

 

 
，就好像 OpenJDK 和 商用的 Orcale 的 JDK
 

 

 

 

 

 

 
，企业版会多一些性能分析的功能              ，用来帮助更大程度的优化性能                     。

社区版是基于OpenJDK 11.0.17, 17.0.5, 19.0.1 

 
 

 
 

 
 

 
 

 
 

 
 

 
，而商业版基于Oracle JDK 8u351, 11.0.17, 17.0.5, 19.0.1













，所以                     ，如果你想用免费的 
 
 
 
 
 
 
 
 
 
 
 
 
 
，只能将程序升级到 JDK 11 以上了
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

GraalVM 支持 Windows                     、Linux
 
 
 
 
 
 
 
 
 
 
 
 
 
 、MacOS 




















，可以用命令安装最新版              ，或者直接下载对应 Java 版本的




















。

我是下载的 Java 11 的版本 
  
 
  
 
  
 
  
 
  
 
  
 
  
，下载下来的压缩包













，直接解压 
  
  
  
  
  
  
 ，然后配置环境变量              。把解压目录配置到环境变量的 JAVA_HOME就可以了
 
  
 
  
 
  
 
  
 
  
 
  
 
  。

解压好其实就相当于安装完毕了 
  
  
  
  
  
  
 ，查看一下版本













。

进入到解压目录下的bin目录中

 


 


 


 


 


 


 
，运行 java -version  
  
  
  
  
  
  
。运行结果如下：

运行代码

常用方式运行

也就是我们平时一直在用的这种方式 
 
 
 
 
 
 
，把 GrralVM 当做 OpenJDK 使用 
   
   
   
   
   
   
  ，只不过把即时编译器换成了 Graal  
  
  
  
  
  
  
 。就是前面说的第一种方式


 


 


 


 


 


 


 。

安装完成后
 

 

 

 

 

 

 
，就可以把它当做正常的 JDK 使用了
 

 

 

 

 

 

 
，比如 javac




















、jps              、jmap等都可以直接用了 
 
 
 
 
 
 
。大多数人还是用 IDEA 的              ，所以就直接在 IDEA 中使用就好了  
   
   
   
   
   
   
 。

1
 
  
 
  
 
  
 
  
 
  
 
  
 
  、先随意创建一个 Java 项目

 

 

 

 

 

 

 。

2













、创建完成后 

 
 

 
 

 
 

 
 

 
 

 
 

 
，打开项目设置
 

 

 

 

 

 

 
。

3  
  
  
  
  
  
  
、在打开的项目设置弹出框中选择 SDKs













，点击加号                     ，选择前面解压的 GraalVM 目录              。

4 
  
  
  
  
  
  
 、然后选择刚刚添加的这个 JDK
 

 
 

 
 

 
 

 
 

 
 

 
 

 。

5


 


 


 


 


 


 


 、最后运行一段测试代码













。

public class HelloWorld { public static void main(String[] args) throws Exception { System.out.println("Hello GraalVM!"); Thread.sleep(1000 * 100 * 100); } }

上面这样的运行方式 
 
 
 
 
 
 
 
 
 
 
 
 
 
，其实就相当于前面说的第一种运行方式

native-image 方式运行

这种方式就是 AOT 编译成机器码




















，已可执行文件的形式出现                     。native-image 可以命令行的形式执行              ，也可以在配合 Maven 执行 
  
 
  
 
  
 
  
 
  
 
  
 
  
，我这儿就直接演示用 Maven 形式的了













，毕竟IDEA 搭配 Maven 用习惯了
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

1 
 
 
 
 
 
 
、安装native-image 工具包

native-image 是用来进行 AOT 编译打包的工具 
  
  
  
  
  
  
 ，先把这个装上 
  
  
  
  
  
  
 ，才能进行后面的步骤




















。

安装好 GraalVM 后

 


 


 


 


 


 


 
，在 bin目录下有一个叫做 gu的工具 
 
 
 
 
 
 
，用这个工具安装 
   
   
   
   
   
   
  ，如果将 bin目录添加到环境中
 

 

 

 

 

 

 
，直接下面的命令安装就行了              。

gu install native-image

如果没有将 bin目录加到环境变量中
 

 

 

 

 

 

 
，要进入到 bin目录下              ，执行下面的命令安装
 
  
 
  
 
  
 
  
 
  
 
  
 
  。

./gu install native-image

这个过程可能比较慢 

 
 

 
 

 
 

 
 

 
 

 
 

 
，因为要去 github 上下载东西













，如果一次没成功（比如超时）                     ，多试两次就好了













。

2  
   
   
   
   
   
   
 、配置 Maven

配置各种版本

<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>${java.specification.version} </maven.compiler.source> <maven.compiler.target>${java.specification.version}</maven.compiler.target> <native.maven.plugin.version>0.9.12</native.maven.plugin.version> <imageName>graalvm-demo-image</imageName> <mainClass>org.graalvm.HelloWorld</mainClass> </properties>

native.maven.plugin.version是要用到的编译为可执行程序的 Maven 插件版本  
  
  
  
  
  
  
。

imageName是生成的可执行程序的名称 
  
  
  
  
  
  
 。

mainClass是入口类全名称


 


 


 


 


 


 


 。

配置 build 插件

<build> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>exec-maven-plugin</artifactId> <version>3.0.0</version> <executions> <execution> <id>java-agent</id> <goals> <goal>exec</goal> </goals> <configuration> <executable>java</executable> <workingDirectory>${project.build.directory}</workingDirectory> <arguments> <argument>-classpath</argument> <classpath/> <argument>${mainClass}</argument> </arguments> </configuration> </execution> <execution> <id>native</id> <goals> <goal>exec</goal> </goals> <configuration> <executable>${project.build.directory}/${imageName}</executable> <workingDirectory>${project.build.directory}</workingDirectory> </configuration> </execution> </executions> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>${maven.compiler.source}</source> <target>${maven.compiler.source}</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>3.2.2</version> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <mainClass>${mainClass}</mainClass> </manifest> </archive> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <executions> <execution> <phase>package</phase> <goals> <goal>single</goal> </goals> </execution> </executions> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <mainClass>${mainClass}</mainClass> </manifest> </archive> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> </configuration> </plugin> </plugins> </build>

配置 profiles

<profiles> <profile> <id>native</id> <build> <plugins> <plugin> <groupId>org.graalvm.buildtools</groupId> <artifactId>native-maven-plugin</artifactId> <version>${native.maven.plugin.version}</version> <extensions>true</extensions> <executions> <execution> <id>build-native</id> <goals> <goal>build</goal> </goals> <phase>package</phase> </execution> <execution> <id>test-native</id> <goals> <goal>test</goal> </goals> <phase>test</phase> </execution> </executions> <configuration> <fallback>false</fallback> <buildArgs> <arg>-H:DashboardDump=fortune -H:+DashboardAll</arg> </buildArgs> <agent> <enabled>true</enabled> <options> <option>experimental-class-loader-support</option> </options> </agent> </configuration> </plugin> </plugins> </build> </profile> </profiles>

3

 

 

 

 

 

 

 、使用 maven 编译 
 
 
 
 
 
 
 
 
 
 
 
 
 
，打包成本地可执行程序 
 
 
 
 
 
 
。

执行 Maven 命令

mvn clean package

或者

mvn -Pnative -Dagent package

编译打包的过程比较慢




















，因为要直接编译成机器码              ，所以比一般的编译过程要慢一些  
   
   
   
   
   
   
 。看到下面的输入日志 
  
 
  
 
  
 
  
 
  
 
  
 
  
，说明打包成功了

 

 

 

 

 

 

 。

4
 

 

 

 

 

 

 
、运行可执行程序包













，打开 target 目录 
  
  
  
  
  
  
 ，已经看到了graalvm-demo-image可执行程序包了 
  
  
  
  
  
  
 ，大小为 11.58M
 

 

 

 

 

 

 
。

然后就可以运行它了

 


 


 


 


 


 


 
，进入到目录下 
 
 
 
 
 
 
，执行下面的命令运行 
   
   
   
   
   
   
  ，可以看到正常输出了              。注意了
 

 

 

 

 

 

 
，这时候已经是没有用到本地 JVM 了
 

 
 

 
 

 
 

 
 

 
 

 
 

 。

./graalvm-demo-image Hello GraalVM!

这时候
 

 

 

 

 

 

 
，用 jps -l命令已经看不到这个进程了              ，只能通过 ps看了













。

总结

虽然我们还没有看到有哪个公司说在用 GraalVM 了 

 
 

 
 

 
 

 
 

 
 

 
 

 
，但是 Quarkus              、Spring Boot
 

 
 

 
 

 
 

 
 

 
 

 
 

 、Spring等很多的框架都已经支持 GraalVM 的 Native-image 模式













，而且在 Orcale 的大力推广下                     ，相信不久之后就会出现在更多的产品中                     。赶紧体验一下吧
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

如果觉得还不错的话 
 
 
 
 
 
 
 
 
 
 
 
 
 
，给个推荐吧！

公众号「古时的风筝」




















，Java 开发者              ，专注 Java 及周边生态




















。坚持原创干货输出 
  
 
  
 
  
 
  
 
  
 
  
 
  
，你可选择现在就关注我













，或者看看历史文章再关注也不迟              。长按二维码关注 
  
  
  
  
  
  
 ，跟我一起变优秀！