What is JIT Compilation?

Direct Answer

Just-in-time compilation translates selected JVM bytecode into native machine code while the program runs. HotSpot profiles execution, compiles hot paths in tiers, applies runtime-informed optimizations, and can deoptimize compiled code when an assumption no longer holds.

Deep Dive & Architecture

Profile first, specialise later

A virtual call may initially see only one implementation. HotSpot can record that observation, inline the common target, and optimise the surrounding code as one path. This removes call overhead and exposes more constant folding or loop optimisation than the bytecode alone would justify.

Speculation needs a safe exit

Suppose a pricing loop has only RegularPrice objects during warm-up. The compiled path can be specialised for that target while retaining metadata needed to recover. If a new DiscountPrice class later appears and invalidates the assumption, execution deoptimises to a correct less-specialised state. The runtime can collect new profiles and compile again. Correctness never depends on the speculation remaining true.

Warm-up is part of the experiment

A short command-line program may finish before highly optimised code pays back its compilation cost. A long-running service can benefit after repeated traffic. Compilation threads, profiles, and compiled methods also consume CPU and code-cache space, so more compilation is not automatically better.

JIT logs and compiler flags describe one implementation, not portable application behaviour. For a real performance question, use a representative workload and a harness such as JMH, consume results so work cannot disappear, separate warm-up from measurement, and inspect diagnostics only after a repeatable difference exists.

Code Example

class JitCompilation {
    static long triangular(int n) {
        long total = 0;
        for (int i = 0; i <= n; i++) total += i;
        return total;
    }

    public static void main(String[] args) {
        long result = 0;
        for (int i = 0; i < 100_000; i++) result = triangular(100);
        System.out.println(result);
    }
}

The loop creates repeated execution; it does not prove which tier a particular JVM chose. Use implementation diagnostics or JMH for that question.