一文带你感受GraalVM的十大用途

女爷i 2023-06-16 08:28 10阅读 0赞

作者| Chris Seaton

译者| 无明

编辑| 张婵

不久前 Oracle 发布了 GraalVM，一套通用型虚拟机，能执行各类高性能与互操作性任务，并在无需额外成本的前提下允许用户构建多语言应用程序。

GraalVM 包含了很多不同的部分，我们将列出 GraalVM 的一些不同的特性，并展示它的用途。

高性能 Java

占用内存小、启动速度快的 Java

组合 JavaScript、Java、Ruby 和 R 语言

在 JVM 上运行本地语言

适用于所有编程语言的工具

扩展基于 JVM 的应用程序

扩展本地应用程序

将 Java 代码作为本地库

数据库中的 polyglot

创建自己的语言

由于篇幅过长，我们只在本文中详细分享前 6 大用途。关于 GraalVM 的更多精彩内容，也可订阅或试读 Oracle Labs 的高级研究员郑雨迪的专栏《深入拆解 Java 虚拟机》。郑雨迪会在单独拿出一个模块的内容来分享 Oracle 的虚拟机黑科技，科普 GraalVM 的各个组成部分，其中包括编译器 Graal，语言实现框架 Truffle，以及支持 Ahead-of-Time（ATO）编译的 SubstrateVM。

我们可以使用 GraalVM 1.0.0 RC 1（https://www.graalvm.org/downloads）来重现本文所述的内容。我是在 macOS 上运行 GraalVM 企业版，不过在 Linux 上运行 GraalVM 社区版也是一样的。文中运行的代码可以从 http://github.com/chrisseaton/graalvm-ten-things 下载。

安 装

我从 https://www.graalvm.org/downloads 下载了 GraalVM 1.0.0 RC 1 企业版，并将它放到 $PATH 路径中。

$ git clone https://github.com/chrisseaton/graalvm-ten-things.git $ cd foo $ tar -zxf graalvm-ee-1.0.0-rc1-macos-amd64.tar.gz \# or graalvm-ee-1.0.0-rc1-linux-amd64.tar.gz on Linux $ export PATH=graalvm-1.0.0-rc1/Contents/Home/bin:$PATH \# or PATH=graalvm-1.0.0-rc1/bin:$PATH on Linux  
GraalVM 内置了 JavaScript，并带有一个叫作gu的软件包管理器，可用它来安装其他语言。我已经安装了从 GitHub 下载的 Ruby、Python 和 R 语言。

$ gu install -c org.graalvm.ruby $ gu install -c org.graalvm.python $ gu install -c org.graalvm.R  
我们可以通过运行 java 或 js 来获得这些运行时的版本信息。

$ java -version java version "1.8.0\_161" Java(TM) SE Runtime Environment (build 1.8.0\_161-b12) GraalVM 1.0.0-rc1 (build 25.71-b01-internal-jvmci-0.42, mixed mode) $ js --version Graal JavaScript 1.0 (GraalVM 1.0.0-rc1)  
高性能

GraalVM 中的 Graal 得名于 Graal 编译器。Graal 是一种“万能”编译器，也就是说，虽然它是单一的实现，却可以用于很多用途。例如，我们可以使用 Graal 进行预编译（ahead-of-time）和即时编译（just-in-time），也可用于编译多种编程语言。

我们可以将 Graal 简单地用作 Java JIT 编译器。

以下的示例程序将会输出一篇文档的前十个单词，它使用了 Stream 和 Collector 等 Java 语言特性。

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.Arrays; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; public class TopTen \{ public static void main(String\[\] args) \{ Arrays.stream(args) .flatMap(TopTen::fileLines) .flatMap(line -> Arrays.stream(line.split("\\\\b"))) .map(word -> word.replaceAll("\[^a-zA-Z\]", "")) .filter(word -> word.length > 0) .map(word -> word.toLowerCase) .collect(Collectors.groupingBy(Function.identity, Collectors.counting)) .entrySet.stream .sorted((a, b) -> -a.getValue.compareTo(b.getValue)) .limit(10) .forEach(e -> System.out.format("%s = %d%n", e.getKey, e.getValue)); \} private static Stream<String> fileLines(String path) \{ try \{ return Files.lines(Paths.get(path)); \} catch (IOException e) \{ throw new RuntimeException(e); \} \} \}  
GraalVM 包含了一个 javac 编译器，但在本例中，它与标准的编译器并没有什么区别。因此，如果你愿意，也可以使用系统的 javac。

$ javac TopTen.java  
如果我们运行 GraalVM 提供的 java 命令，将会自动调用 Graal JIT 编译器，不需要做额外的配置。我使用 time 命令来获得整个程序从开始到运行结束所花费的时间，而不是进行复杂的微基准测试。我使用了大量的输入，这样就不用去纠结几秒钟的差别。我使用的 large.txt 文件大小为 150MB。

$ make large.txt $ time java TopTen large.txt sed = 502701 ut = 392657 in = 377651 et = 352641 id = 317627 eu = 317627 eget = 302621 vel = 300120 a = 287615 sit = 282613 real 0m17.367s user 0m32.355s sys 0m1.456s  
Graal 是使用 Java 开发的，而其他大多数 Java JIT 编译器是使用 C++ 开发的。我们因此能够比其他编译器更快地改进它，而且它具备了强大的优化功能，比如 HotSpot 标准 JIT 编译器中所没有的部分转义分析功能。这项优化功能可以让 Java 程序的运行速度明显加快。

为了与不使用 Graal JIT 编译器时的速度进行比较，我使用 -XX:-UseJVMCICompiler 标记来运行程序。JVMCI 是 Graal 和 JVM 之间的接口。当然，我们也可以拿它与标准的 JVM 进行比较。

$ time java -XX:-UseJVMCICompiler TopTen large.txt sed = 502701 ut = 392657 in = 377651 et = 352641 id = 317627 eu = 317627 eget = 302621 vel = 300120 a = 287615 sit = 282613 real 0m23.511s user 0m24.293s sys 0m0.579s  
结果显示，使用 Graal 运行程序的时间大约是标准 HotSpot 的四分之三。在习惯于将单个位数的百分比性能增长视为显著改进的今天，这个数字算得上是一个巨大的提升。

Twitter 是在生产环境中使用 Graal 的公司之一，他们表示，Graal 确确实实为他们省下了不少钱。Twitter 使用 Graal 来运行 Scala 应用程序。因为 Graal 执行的是 JVM 字节码，因此适用于任何基于 JVM 的语言。

这是 GraalVM 的第一个用途——将它作为 Java 应用程序的一个更好的 JIT 编译器。

占用内存小、启动速度快的 Java

Java 对于长时间运行的进程来说是相当强大的，但短时间运行的进程可能会因较长的启动时间和较高的内存占用而饱受其苦。

例如，如果我们使用更小的输入来运行相同的应用程序（文件大小约为 1KB，而不是 150MB），似乎需要花费更长的时间，并且需要 60MB 的内存。我们使用 -l 选项打印出它所消耗的内存和运行时间。

$ make small.txt $ /usr/bin/time -l java TopTen small.txt \# -v on Linux instead of -l sed = 6 sit = 6 amet = 6 mauris = 3 volutpat = 3 vitae = 3 dolor = 3 libero = 3 tempor = 2 suscipit = 2 0.32 real 0.49 user 0.05 sys 59846656 maximum resident set size ...  
GraalVM 为我们提供了解决这个问题的工具。可以说 Graal 就是一个编译器软件包，有许多不同的使用方式，其中之一就是将源码预编译为本地可执行镜像，而不是在运行时进行即时编译。这与传统的编译器 gcc 类似。

$ native-image --no-server TopTen classlist: 1,513.82 ms (cap): 2,333.95 ms setup: 3,584.09 ms (typeflow): 4,642.13 ms (objects): 3,073.58 ms (features): 156.34 ms analysis: 8,059.94 ms universe: 353.02 ms (parse): 1,277.02 ms (inline): 1,412.08 ms (compile): 10,337.76 ms compile: 13,776.23 ms image: 2,526.63 ms write: 1,525.03 ms \[total\]: 31,439.47 ms  
这个命令会生成一个名为 topten 的本地可执行文件。这个可执行文件并不是 JVM 的启动程序，它不需要链接到 JVM，也不以任何方式捆绑 JVM。native-image 会将 Java 代码和所使用的 Java 库直接编译成机器码。我们还使用了 SubstrateVM 虚拟机，它和 Graal 一样，也是用 Java 编写的。

如果我们看一下 topten 所使用的库，就会发现它们都只是标准的系统库。我们也可以将这个文件移动到一个从未安装过 JVM 的系统上运行，以此来验证它确实没有使用 JVM 或任何其他文件。它的体积很小——这个可执行文件不到 6MB。

$ otool -L topten \# ldd topten on Linux topten: .../CoreFoundation.framework ... .../libz.1.dylib ... .../libSystem.B.dylib ... $ du -h topten 5.7M topten  
与在 JVM 上运行相同的程序相比，可执行文件的启动速度快了一个数量级，使用的内存少了一个数量级。它的速度非常快，快到让你注意不到在命令行上所花费的时间，而且感觉不到停顿。

$ /usr/bin/time -l ./topten small.txt sed = 6 sit = 6 amet = 6 mauris = 3 volutpat = 3 vitae = 3 dolor = 3 libero = 3 tempor = 2 suscipit = 2 0.02 real 0.00 user 0.00 sys 4702208 maximum resident set size ...  
不过，native-image 这个工具也存在一些约束，比如所有的类在编译期间都必须可用。除此之外，在反射方面也存在一些限制。除了基本的编译功能之外，它还提供了额外的高级特性，即在编译期间运行静态初始化器，以便在加载应用程序时可以少做一些事情。

这是 GraalVM 的第二个用途——以低内存占用和快速启动来运行现有的 Java 程序。它为我们省去了一些配置问题，比如如何在运行时查找正确的 jar 文件。它还能让 Docker 镜像的体积变得更小。

组合 JavaScript、Java、Ruby 和 R 语言

除了 Java，GraalVM 还包含了 JavaScript、Ruby、R 语言和 Python 的实现。它们都是使用一个叫作 Truffle 的语言实现框架开发的，Truffle 让实现简单且高性能的语言解释器成为可能。在使用 Truffle 开发语言解释器时，会自动使用 Graal 作为 JIT 编译器。因此，Graal 不仅是 Java 的 JIT 编译器和预编译器，也可以是 JavaScript、Ruby、R 语言和 Python 的 JIT 编译器。

GraalVM 中的语言旨在成为现有语言的直接替代品。例如，我们可以安装一个 Node.js 模块：

$ npm install --global color ... + color@3.0.0 added 6 packages in 14.156s  
我们可以使用此模块编写一个小程序，将 RGB HTML 颜色转换为 HSL：

var Color = require('color'); process.argv.slice(2).forEach(function (val) \{ print(Color(val).hsl.string); \});  
然后用常规的方式运行它：

$ node color.js '\#42aaf4' hsl(204.89999999999998, 89%, 60.8%)  
GraalVM 提供了一个 API，用以在一门语言中运行另一门语言的代码。因此，我们可以使用多种语言来开发一个应用程序。

我们可能希望用一种语言开发应用程序的主要部分，同时又使用另一种语言的软件包。例如，假设我们用 Node.js 开发一个将 CSS 颜色名称转换为十六进制数的应用程序，但又希望使用 Ruby 颜色库来完成转换。

var express = require('express'); var app = express; color\_rgb = Polyglot.eval('ruby', \` require 'color' Color::RGB \`); app.get('/css/:name', function (req, res) \{ color = color\_rgb.by\_name(req.params.name).html res.send('<h1 style="color: ' + color + '" >' + color + '</h1>'); \}); app.listen(8080, function  \{ console.log('serving at http://localhost:8080') \});  
我们以字符串形式提供了一小串 Ruby 代码——导入必要的库，然后返回一个 Ruby 对象。要在 Ruby 中使用这个对象，通常需要这样：Color::RGB.by\_name(name).html。而在我们的例子中，我们是在 JavaScript 里调用这些方法，即使它们是 Ruby 的对象和方法。并且，我们传给它一个 JavaScript 字符串，然后把结果连接起来，结果里包含了 Ruby 字符串和其他 JavaScript 字符串。

下面安装 Ruby 和 JavaScript 的依赖项。

$ gem install color Fetching: color-1.8.gem (100%) Successfully installed color-1.8 1 gem installed $ npm install express + express@4.16.2 updated 1 package in 10.393s  
然后，我们需要使用以下几个选项来运行 node：--polyglot 表示我们想要访问其他语言，--jvm 表示要使用 JVM，因为默认情况下 node 本地镜像只包含了 JavaScript。

$ node --polyglot --jvm color-server.js serving at http://localhost:8080  
然后在浏览器中打开 http://localhost:8080/css/aquamarine。除了 aquamarine，也可以使用其他颜色名称。

图片: https://images-cdn.shimo.im/maemEQ9DMI0JZAtY/1.png!thumbnail 接下来让我们尝试使用更多的语言和模块。

对于任意大的整数，JavaScript 并没有很好的解决方案。我发现了几个像 big-integer 这样的模块，但这些模块的性能并不好，因为它们将数字的组成部分存储为 JavaScript 浮点数。Java 的 BigInteger 性能更好，所以我们用它来做一些任意大的整数运算。

JavaScript 也不提供对图形绘制的内置支持，而 R 语言却对此提供了很好的支持。我们使用 R 语言的 svg 模块绘制三角函数的三维散点图。

我们可以使用 GraalVM 的 polyglot API，并将其他语言代码的运行结果添加到 JavaScript 中。

const express = require('express') const app = express const BigInteger = Java.type('java.math.BigInteger') app.get('/', function (req, res) \{ var text = 'Hello World from Graal.js!<br> ' // Using Java standard library classes text += BigInteger.valueOf(10).pow(100) .add(BigInteger.valueOf(43)).toString + '<br>' // Using R interoperability to create graphs text += Polyglot.eval('R', \`svg; require(lattice); x <- 1:100 y <- sin(x/10) z <- cos(x^1.3/(runif(1)\*5+10)) print(cloud(x~y\*z, main="cloud plot")) grDevices:::svg.off \`); res.send(text) \}) app.listen(3000, function  \{ console.log('Example app listening on port 3000!') \})  
在浏览器中打开 http://localhost:3000/ 查看结果。

图片: https://images-cdn.shimo.im/LS2Lt9CD7NY0u7Dz/2.png!thumbnail 这是 GraalVM 的第三个用途——运行使用多种语言编写的程序，并组合使用这些语言的模块。我认为这是语言和模块的大众化——你可以为你的问题选择任何一门合适的语言以及任何你想要的库。

在 JVM 上运行本地语言

GraalVM 也支持 C 语言，GraalVM 可以像运行 JavaScript 和 Ruby 之类的语言一样运行 C 代码。

实际上，GraalVM 通过运行 LLVM 位码的方式来支持 C 语言，而不是直接运行 C 代码。也就是说，我们可以将现有工具与 C 语言一起使用，还可以使用其他可输出 LLVM 的语言，例如 C++、Fortran 和未来可能出现的其他语言。为了简化演示，我使用了由 Stephen McCamant 维护的 gzip 的单文件版本。为简单起见，它只是将 gzip 源代码和 autoconf 配置连成一个单独的文件。我还需要修改一些东西才能让它在 macOS 上运行起来，但不能在 GraalVM 上运行。

然后我们使用标准 clang（LLVM C 语言编译器）来编译它，并把它编译成 LLVM 位码，而不是本地汇编代码，这样就可以在 GraalVM 上运行。我使用的是 clang 4.0.1。

$ clang -c -emit-llvm gzip.c  
然后我们使用 lli 命令（LLVM 位码解释器）直接在 GraalVM 上运行编译后的位码。我们先使用系统 gzip 来压缩文件，然后使用运行在 GraalVM 上的 gzip 进行解压缩。

$ cat small.txt Lorem ipsum dolor sit amet... $ gzip small.txt $ lli gzip.bc -d small.txt.gz $ cat small.txt Lorem ipsum dolor sit amet...  
GraalVM 中的 Ruby 和 Python 实现也使用了这种技术来运行 C 扩展。也就是说，我们可以在虚拟机内部运行 C 扩展，同时保持高性能。

这是 GraalVM 的第四个用途——运行使用 C 和 C++ 等本地语言编写的程序，并且还可以运行 C 语言扩展，而像 JRuby 这样的 JVM 是无法做到这点的。

适用于所有编程语言的工具

如果你使用 Java 编程，可能已经习惯了使用那些高质量的工具，比如 IDE、调试器和分析器，但并非所有的编程语言都有这么好用的工具。不过如果你是在 GraalVM 中使用某种语言，就可以获得这样的工具。

所有 GraalVM 语言（目前除了 Java）都是使用 Truffle 框架实现的，所以一个功能只要开发一次（比如调试器），就可以用在所有语言上。

为了试验这个功能，我们开发了一个简单的 FizzBuzz 程序。它将内容输出到屏幕上，逻辑分支很清晰，只需要进行少量迭代，我们因此可以很容易地设置断点。我们先使用 JavaScript 来实现。

$ js fizzbuzz.js 1 2 Fizz 4 Buzz Fizz ...  
我们也可以用 --inspect 标记来运行它，它会输出一个可以在 Chrome 中打开的链接，并在调试器中暂停程序的运行。

$ js --inspect fizzbuzz.js Debugger listening on port 9229. To start debugging, open the following URL in Chrome: chrome-devtools://devtools/bundled/inspector.html?ws=127.0.0.1:9229/6c478d4e-1350b196b409 ...  
然后我们在 FizzBuzz 代码中设置一个断点，并继续执行。在跳过断点后，我们可以看到 n 的值，然后继续，或者查看调试接口的其余部分。

这个标志也可用在 Python、Ruby 和 R 语言上。我就不展示每个程序的源代码了，它们的运行方式都是一样的。

$ graalpython --jvm --inspect fizzbuzz.py

$ ruby --inspect fizzbuzz.rb

$ Rscript --inspect fizzbuzz.r

你可能对 Java 的另一个工具 VisualVM 很熟悉，它为我们提供了一个用户界面，可以将它连接到本机或网络上的某个 JVM，以便检查各种问题，比如内存和线程的使用情况。

GraalVM 也包含了带有标准 jvisualvm 命令的 VisualVM。

$ jvisualvm &> /dev/ &  
如果我们在运行 TopTen Java 应用程序的同时运行 jvisualvm，就可以看到内存随时间变化的情况，或者我们可以做一些其他的事情，比如进行堆转储，然后检查堆中的对象类型。

$ java TopTen large.txt

我写了一个用来生成垃圾的 Ruby 程序。

require 'erb' x = 42 template = ERB.new <<-EOF The value of x is: <%= x %> EOF loop do puts template.result(binding) end  
如果使用 VisualVM 来运行标准的 JVM 语言（如 JRuby），则会感到失望，因为你看到的是底层的 Java 对象，而不是所使用语言的对象的信息。

如果我们使用 Ruby 的 GraalVM 版本，VisualVM 将会识别出 Ruby 对象。我们需要使 --jvm 选项来启动 VisualVM，因为它不支持本地版本的 Ruby。

$ ruby --jvm render.rb  
如果有需要的话，我们还可以看到底层 Java 对象的堆转储，或者在 Summary 下选择 Ruby Heap 来查看 Ruby 对象。

图片: https://images-cdn.shimo.im/eNJCsYUOgoE11Yrc/8.png!thumbnailTruffle 框架就像是编程语言和工具之间的一种联系。如果我们使用 Truffle 来开发自己的编程语言，并基于 Truffle 的工具 API 开发各种工具（比如调试器），那么开发出来的工具可以适用于每一种语言，而且只需要开发一次即可。

这是 GraalVM 的第五个用途——为编程语言提供高质量的工具。

扩展基于 JVM 的应用程序

除了可用作独立语言实现和用于多语言编程，这些语言和工具也可以嵌入到 Java 应用程序中。新的 org.graalvm.polyglot API 可用于加载和运行其他语言的代码。

import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Value; public class ExtendJava \{ public static void main(String\[\] args) \{ String language = "js"; try (Context context = Context.newBuilder.allowNativeAccess(true).build) \{ for (String arg : args) \{ if (arg.startsWith("-")) \{ language = arg.substring(1); \} else \{ Value v = context.eval(language, arg); System.out.println(v); \} \} \} \} \}  
如果我们使用了 GraalVM 的 javac 和 java 命令，那么 org.graalvm…就已经存在于类路径中，可以直接编译并运行代码，不需要使用任何额外的标记。

$ javac ExtendJava.java $ java ExtendJava '14 + 2' 16 $ java ExtendJava -js 'Math.sqrt(14)' 3.7416573867739413 $ java ExtendJava -python '\[2\*\*n for n in range(0, 8)\]' \[1, 2, 4, 8, 16, 32, 64, 128\] $ java ExtendJava -ruby '\[4, 2, 3\].sort' \[2, 3, 4\]  
这些版本的语言与通过使用 node 和 ruby 这些命令运行的代码一样，都具备了很高的性能。

这是 GraalVM 的第六个用途——作为在 Java 应用程序中嵌入不同语言的接口。我们可以借助 polyglot API 来获取其他语言的对象，并将它们用作 Java 接口，实现其他复杂的操作。

结 论

GraalVM 支持多种新功能，它是一个平台，我们可以在这个平台上构建更强大的语言和工具，并将它们放入更多的环境中。无论程序在哪里运行，或者使用了哪种语言，它都可以让我们选择所需的语言和模块。  
原文链接：https://blog.csdn.net/weixin\_33979203/article/details/86720387