技術文章 » 過兩年 JVM 可能就要被 GraalVM 替代了

過兩年 JVM 可能就要被 GraalVM 替代了

2022-12-16 12:01:02

大家好，我是風箏，公眾號「古時的風箏」，專注於 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 及周邊生態。堅持原創乾貨輸出，你可選擇現在就關注我，或者看看歷史文章再關注也不遲。長按二維條碼關注，跟我一起變優秀！