What Is JIT Compilation in Java and How Does It Boost Performance?

Compilation Types

Compilation is the process of translating source code into machine‑understandable instructions. The result is machine code that the CPU executes. The article first distinguishes static compilation, which produces machine code ahead of time, from just‑in‑time (JIT) compilation, which occurs at runtime.

Just‑In‑Time (JIT) Compilation

JIT compilation converts bytecode into native machine code while the program runs. Languages such as Java, ActionScript, and C# (via CIL) use this approach. Because the compilation happens on the executing machine, the generated code can be optimized for the specific hardware.

Key advantages are:

Hardware‑specific optimizations that static compilers cannot apply.

Portability: the same bytecode runs on any platform that provides a compatible virtual machine.

JIT in Java

Java’s javac produces bytecode, not native code. At runtime the JVM’s JIT compiler translates hot methods into machine code. The article shows how to enable diagnostic flags to observe JIT activity: -XX:+PrintCompilation – prints compilation results with timestamps and method sizes. -XX:+UnlockDiagnosticVMOptions – enables additional diagnostic options. -XX:+PrintInlining – displays inlining decisions made by the JIT.

Sample output (formatted as columns) includes a timestamp, a compilation task ID, and the size of the compiled bytecode, e.g.,

71 1 java.lang.String::indexOf (70 bytes)
73 2 sun.nio.cs.UTF_8$Encoder::encode (361 bytes)
87 3 java.lang.String::hashCode (55 bytes)

Inlining replaces a call to a small method with the method’s body, eliminating the call overhead. An example method:

public void testMethod() {
    callAnotherMethod();
}

When -XX:+PrintInlining is enabled, the JIT may inline callAnotherMethod(), removing the call jump.

Other JIT Optimizations

The JVM performs several additional optimizations:

Lazy compilation – only methods actually executed are compiled.

Adaptive optimization – frequently used code paths are re‑compiled with more aggressive optimizations.

Dead‑code elimination – removes bytecode that is never executed.

Loop optimizations – restructures loops and can transform tail‑recursion into iterative loops.

Interface method de‑virtualization – replaces an interface call with a direct call when the concrete implementation is known.

Compiled methods are stored in the code cache; subsequent calls can reuse the cached native code unless a better optimized version is generated.