When Java Performance Matters, What Do You Do?

Summary 

Oracle has removed the Graal JIT compiler for Java performance from the Oracle JDK, and is advising GraalVM users to transition to Oracle JDK or OpenJDK. With this development, Azul Platform Prime is the only option for organizations that want a high-performance Java platform.

 In this post you will learn: 

• Oracle has removed the Graal JIT compiler rom the Oracle JDK 

• Oracle encourages GraalVM users to transition to Oracle JDK or OpenJDK 

• If you need better performance for your Java applications, you need a high-performance Java platform

Someone asked me recently to sum up, in less than a minute, what constitutes Java performance. Clearly, this is a complex and involved subject, which we could have discussed for hours if not days (I know there are training courses like that). 

However, the answer I came up with was that there are three fundamental concepts you need to be aware of: 

1. Latency. Because the JVM handles memory management for the application automatically, this can have a profound impact on how quickly an application responds to a request. If the garbage collector (GC) pauses application threads while it does its work, this can lead to a delay in responding, potentially even taking minutes. 

2. Throughput. How many transactions a second can an application process?  This will depend heavily on the hardware resources available —cores, memory, etc. —and on how efficiently the JVM can convert bytecodes to native instructions via just-in-time (JIT) compilation. 

3. Warmup time. A more subtle performance factor, but just as important, is the warmup time for an application. Bytecodes deliver on the write once, run anywhere promise of Java, but when the JVM is interpreting them, they run much more slowly than native code. That’s why the JIT was added in JDK 1.2. However, it takes time to identify all the frequently used code and compile it. Warmup time is therefore the time it takes to reach the optimal level of application performance (and thus throughput, in transactions per second). 

In the last 30 years, we’ve seen a remarkable number of approaches to address these three aspects of Java performance. Just consider the number of GC algorithms the JVM has included. Even now, we see considerable effort being devoted to Project Leyden in OpenJDK, which aims to address warmup time issues. 

There have also been projects outside the core Java platform developing ways to improve performance. One of the most prominent was GraalVM.

What should I know about GraalVM?

Unfortunately, GraalVM has become a somewhat overloaded term encompassing several interrelated projects. This started life as a research project at Sun Labs and continued at Oracle after the acquisition of Sun Microsystems. GraalVM delivered a set of technologies designed to provide a runtime for a polyglot environment. These are the basic parts: 

• The Graal JIT compiler. This was the original Graal project, which is easy to confuse with the GraalVM. This is a JIT compiler written entirely in Java; the idea being that using Java would make the compiler easier to maintain and enhance. 

• The Truffle language interpretation framework. This provides a way to translate a variety of programming languages, including Java, into a form that the Graal JIT compiler can compile. 

• The Substrate VM. This is an embeddable VM for a subset of Java, optimised to execute Truffle languages ahead of time. 

For users looking for a better-performing Java runtime, GraalVM enabled the creation of native-image representations of the application. Referring to my definitions above, this provided a compelling solution only for the third aspect: warmup time. By compiling directly to native instructions for a target platform and incorporating the Substrate JVM, JIT compilation is eliminated, delivering full speed from the start. 

Over time, we saw more synergies between the GraalVM team and the Oracle Java Engineering Group. The Oracle JDK even included the Graal JIT compiler from JDK 23.

Is GraalVM still available for Java?

However, recent announcements from Oracle have shown that this is no longer a direction they are pursuing as a high-performance Java solution. From JDK 25 onward, the Graal JIT compiler has been removed from the Oracle JDK (it was never contributed to the OpenJDK, so other distributions have not included it). 

More importantly, Oracle announced that it was “Detaching GraalVM from the Java Ecosystem Train.” The details provided in the blog post explain this further: 

• The GraalVM teams are transitioning to focus on non-Java Graal Languages, including GraalPy and GraalJS. 

• GraalVM for JDK 24 was the final GraalVM release licensed and supported as part of Oracle Java SE Products. 

• Oracle JDK 24 was the final release to include the experimental and optional Graal JIT. 

• GraalVM Early Adopter technology, including Native Image, is being discontinued for Java SE Product customers. 

Oracle’s advice is, “GraalVM users interested in Java technology are encouraged to transition to Oracle JDK or Oracle OpenJDK releases.”  Essentially, this means reverting to using OpenJDK builds.

Where can you turn now for Java performance?

What if you need better performance for your Java applications, including lower latency, higher throughput, as well as reduced warmup time? With Oracle exiting the high-performance Java platform space, the market now falls into two distinct camps: standard OpenJDK distributions (Oracle Java SE, Amazon Corretto, Azul Platform Core) and high-performance Java platforms.

Luckily, Azul has the solution to this in the form of our Platform Prime high-performance Java platform [Figure 1]. Platform Prime delivers lower latency using the C4 garbage collector and higher throughput from more optimized code generated by the Falcon JIT compiler. It also has a range of solutions for improved warmup: ReadyNow profiles that tell the JVM what to compile immediately, the Cloud Native Compiler to offload JIT to a centralised service, and even CRaC to restart an application instantly from a pre-saved state. 

If you’re looking for high performance for your Java applications, why not give it a try? You should do your homework, of course. Read our new high-performance Java platform comparison guide to learn more about your options.