過兩年 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 及周邊生態，堅持原創干貨輸出，你可選擇現在就關注我，或者看看歷史文章再關注也不遲，長按二維碼關注，跟我一起變優秀！

標籤：Java

上一篇：Go語言性能剖析利器--pprof實戰

下一篇：深度剖析 | 【JVM深層系列】[HotSpotVM研究系列] JVM調優的"標準引數"的各種陷阱和坑點分析（攻克盲點及混淆點）「 1 」