JVM Performance

C1 compiles quickly with light optimizations and inserts profiling counters; C2 compiles slowly but aggressively — inlining, loop unrolling, escape analysis — guided by that profile. Tiered compilation, the default, runs both: a method starts interpreted, is promoted to C1 once its counters cross a threshold, and is recompiled by C2 once it proves hot.

Pattern.compile dominates the profile and sits directly under SkuValidator.isValid, so a regex is compiled on every request — the code calls Pattern.compile, or String.matches/split, inside the request path. Compiling parses the pattern into a node tree and costs far more than matching with a ready one. Hoist it into a static final Pattern and only match per request.

A descriptor lists the parameters in order inside the parentheses and the return type after them, encoding I as int, J as long, a leading [ as an array and Lcom/foo/Bar; as a reference type. So this one is public static List<String> pick(String s, int[] a, long n) — the generic argument is erased. javap -s prints descriptors and -p adds private members.

A training run records which classes the app loads; -XX:AOTMode=create then writes an AOT cache holding them already parsed, verified and linked. The next start maps that cache in instead of loading and linking every class file, so a class-heavy app starts markedly faster. It shipped in Java 24, extends AppCDS, and compiles no method to machine code.

Escape analysis proves an allocation never leaves its method or thread. C2 then applies scalar replacement: the object is split into fields held in registers, so no heap allocation happens — HotSpot does not literally put it on the stack — and locks on it are elided. It fires only after inlining, so returning the reference, storing it in a field, or a callee C2 will not inline forces a real allocation.

javac emits invokestatic for static methods and invokespecial for constructors, private methods and super. calls — all bound to one target at compile time. Instance calls emit invokevirtual or invokeinterface: the compiler fixes only the name and descriptor, and the JVM picks the override from the receiver's runtime class per call. C2 devirtualizes a monomorphic site.

System.out is a PrintStream created with autoflush on, and its methods are synchronized: every println takes the stream's monitor, flushes and issues a write syscall, so N iterations cost N syscalls and threads serialize on one lock. A parameterized logger call formats nothing when the level is off and batches through a buffered or async appender.

This is a file-descriptor leak, not an undersized limit: 3968 of the 4092 handles are report CSVs the process has finished writing. A forced GC drops the count to 231, which proves the streams are closed only by their Cleaner when collected — writeReport never calls close(). Wrap it in try-with-resources; raising ulimit -n only postpones the failure.

First fix the baseline: benchmark the current loop with JMH and check whether C2 already auto-vectorizes it — a 3x laptop number against unoptimized scalar code proves nothing. It pays off only if the loop is CPU-bound, data-parallel over contiguous primitives and branch-free. Then price the incubator status, and adopt only behind an interface with a scalar fallback.