Java JVM & Performance

Java JVM & Performance is a free practice course on Abekus built around 1,700+ MCQs covering everything between your Java code and the bytes running on the CPU — the JVM's runtime data areas, the heap and its generations, the GC algorithms (Serial, Parallel, G1, ZGC, Shenandoah), JIT compilation, class loading, the Java Memory Model, profiling and diagnostic tooling, and the -XX tuning flags that turn a server-class JVM into a tuned production runtime.

The format is one question at a time with an explanation that fires the moment you click a wrong answer. No videos, no skimming a 600-page book — retrieval practice on the questions senior interviewers and on-call engineers actually face. You will trace heap allocation paths, predict whether a snippet triggers a young-gen or old-gen collection, recognise GC log patterns, and pick the right -XX flag for a workload.

• Format — 1,700+ free MCQs with instant explanations after every wrong answer.
• Duration — about 19.1 hours of focused practice; most learners finish over 4–6 weeks at 45–60 minutes a day.
• Level — advanced. Assumes Java fundamentals, comfort with the Collections framework, and basic concurrency vocabulary. The JVM topic is the deepest part of the Java surface area.
• Cost — free, with a free completion certificate.
• Audience — senior backend engineers preparing for staff-level interviews, on-call engineers debugging GC pauses in production, SRE-adjacent Java developers, and engineers in fintech, payments, ad-tech, and trading where a 200ms tail-latency from a GC pause is a real business cost.
• Recommended before this — Java Fundamentals and ideally Java Concurrency & Multithreading (the JMM topic builds on the Concurrency course's coverage).
• Companion course — Java Interview Mastery for the broader senior-interview trap set.

Three audiences specifically. First, senior backend engineers preparing for staff-level interviews at product companies, where the JVM round is the filter that distinguishes a strong senior from a staff candidate — "explain what happens between System.out.println and the output appearing", "how would you diagnose a 99th-percentile latency spike", "what's the difference between G1 and ZGC". Second, on-call engineers who have stared at a GC log at 2am and wished they understood it — the Profiling & Diagnostics and Performance Patterns topics are written for exactly that audience. Third, engineers in latency-sensitive domains (trading, payments, ad-tech, real-time bidding) where understanding GC pause profiles and JIT compilation behaviour is a daily skill.

This course is not a Java starter. It assumes you have written Java in production, can read a 20-line synchronized method, know what a HashMap is, and have heard of garbage collection. If you do not yet have that ground, take Java Fundamentals and Java Concurrency & Multithreading first — the JVM topics here will be far more useful once you have working concurrency intuition.

JVM foundations — what the machine actually is

• Introduction to the JVM — JVM history and philosophy, the execution model (bytecode → interpreter → JIT), why Java is fast despite running on a virtual machine.
• JVM Architecture — runtime data areas (heap, stack, metaspace, code cache, native memory), the execution engine, and the class-file structure your javac output writes.
• Heap & Object Memory — heap regions (Eden, Survivor, Old), object lifecycle and allocation paths, escape analysis, and the non-heap and off-heap memory (DirectByteBuffer, Unsafe) you do not get for free.

The core machinery — GC, JIT, JMM, and classloading

• Garbage Collection Fundamentals — reachability, GC roots, mark / sweep / copy / compact, the generational hypothesis, and GC performance metrics (throughput, pause time, allocation rate, footprint).
• GC Collectors — Serial and Parallel collectors (when each still fits), G1 GC in depth (the default since JDK 9), and the low-latency collectors (ZGC, Shenandoah) with their pause-time guarantees.
• JIT Compilation — C1 vs C2 tiers, the optimisations the JIT actually applies (inlining, escape analysis, lock elision, dead-code elimination), and code-cache pressure as a production constraint.
• Class Loading — parent-delegation, bootstrap / platform / system classloaders, the initialisation lifecycle (loading, linking, initialisation), and advanced patterns (custom classloaders, hot reload, classloader leaks).
• Java Memory Model — visibility, ordering, happens-before edges, safe-publication patterns, and the JMM pitfalls (double-checked locking without volatile, racy reads, the publish-and-mutate trap) that survive review and break production.

Production work — profiling, patterns, and tuning

• Profiling & Diagnostics — JVM diagnostic tools (jstat, jcmd, jmap, jstack), modern profilers (async-profiler, JFR, perf), and heap-and-GC analysis workflows you can apply on-call.
• Performance Patterns & Anti-Patterns — memory-efficient data structures, hot-path optimisation (boxing avoidance, allocation reduction, inline caches), and the canonical memory-leak shapes (caches without eviction, ThreadLocal leaks in app-server pools, listener references not unregistered).
• JVM Tuning — heap and memory flags (-Xmx, -Xms, -XX:MaxDirectMemorySize), GC tuning flags by collector, compiler and runtime flags. What is worth pulling vs what is cargo-culted.
• JVM & Performance in Practice — concept comparisons (G1 vs ZGC, throughput vs latency, heap vs off-heap), pattern selection (which collector for which workload, which tool for which symptom), and applied scenarios that combine every previous topic.

The single most-asked GC question at senior Java interviews and one this course gives you a real answer to. G1 is the modern default — region-based, generational, mixed throughput-and-pause profile, predictable up to mid-size heaps (~100GB), pauses in the tens-of-milliseconds range. ZGC is the low-pause collector — sub-10ms pauses regardless of heap size, designed for hundreds-of-GB heaps, trades CPU and memory overhead for predictable latency. Shenandoah is in the same low-pause family — concurrent evacuation, OpenJDK origin, sub-10ms pauses with a slightly different operational profile and overhead pattern.

The course works through these with output-prediction questions on GC log entries, pattern-selection questions (this trading system needs sub-5ms tail latency on a 64GB heap — which collector?), and trap questions (a workload that allocates short-lived garbage at 1GB/sec will defeat G1 in specific ways the explanation walks through). The GC Collectors and In Practice topics drill these comparisons until pattern selection is reflex.

Active recall on real GC logs and real bytecode, not skimming the JDK enhancement proposals. The JVM is unusually rule-dense — pause modes, allocation paths, JIT thresholds, classloader delegation rules — and you do not internalise any of it from a single book. MCQ practice forces production every question: what does this GC log line mean? What flag would have prevented this? Why is this lock-elision optimisation impossible here?

Spacing matters too. 45–60 minutes a day for 4–6 weeks beats one cram weekend because JVM internals have the highest rule-density of any Java topic. The Abekus AI guide also surfaces topics you keep missing more often, so weak spots (often the JMM topic or the GC log patterns) get extra repetition.

One question at a time. Many questions are bytecode-level or log-level — you read a snippet of Java with an annotation about what the JIT did, or a fragment of a GC log, and pick the option matching the cause or the consequence. Wrong answers trigger an explanation that walks through the actual mechanism — the safepoint that gated a particular GC pause, the C2 deoptimisation triggered by a megamorphic call site, the classloader-leak pattern hidden inside a hot-reload framework.

The Abekus AI guide tracks which topics you keep getting wrong. If you nail GC fundamentals but keep mis-predicting JIT inlining behaviour, the next session leans on the JIT topic. The certificate at the end is gated on completing every top-level topic, so the depth signal is honest.

Plan on roughly 19.1 hours of focused practice. The math: 1,719 active questions × ~40 seconds per question (reading the snippet, picking an answer, skimming the explanation when wrong) = ~1,146 minutes = ~19.1 hours.

Most learners spread that across 4–6 weeks at 45–60 minutes a day. JVM questions are denser than language-basic questions — you are often interpreting a log line or a bytecode-level annotation — so the 40-second average is conservative. Trust the spacing; the JMM and GC-log questions in particular only stick after you have seen each pattern rephrased multiple times.

This course is the deepest topic in the Java Mastery track and ideally taken late. Before this, take Java Fundamentals for the language ground and Java Concurrency & Multithreading for the threading model the JMM topic builds on. The Concurrency course covers the JMM at the visibility and happens-before level; this one extends it to the hardware-and-runtime side (memory barriers, safe-publication patterns at scale, JIT-driven reorderings).

For senior or staff interviews, Java Interview Mastery revisits JVM topics as trap questions — useful as a complement to the depth practice here. Java Streams & Functional Programming is a useful adjacent: parallel streams use the common ForkJoinPool, and understanding the JVM's allocation profile is what makes parallel-stream decisions sharp at scale.