Software Development
JVM Performance Tuning and Troubleshooting
An advanced diagnostics course for engineers who own Java systems in production. Participants measure before they tune, examining memory layout, garbage collection behaviour, thread contention, and allocation pressure with Flight Recorder, heap dumps, and benchmarks rather than flags copied from a forum thread.
Overview
Practical learning for workplace transfer.
Most Java performance work fails for one reason: the team changes flags before it knows where the time goes. Heap sizes are raised to hide a leak, a collector is switched to solve a lock contention problem, capacity is doubled to absorb an allocation defect, and a benchmark measures JIT warm-up rather than the code under test. This course establishes measurement discipline first. Participants read garbage collection logs and Flight Recorder profiles, analyse heap dumps to locate retained objects, diagnose contention and thread starvation from thread dumps, and choose deliberately between throughput and latency with numbers that defend every change they propose.
Prerequisites
Several years of Java development or operations experience and familiarity with running Java applications in a server environment.
Objectives
- Interpret JVM memory structure, allocation behaviour, and garbage collection logs.
- Select and size a collector, G1, ZGC, or Parallel, against a stated latency or throughput goal.
- Profile CPU, allocation, and lock contention with JDK Flight Recorder and Mission Control.
- Analyse heap dumps to identify leaks, retained sets, and the true owner of memory.
- Diagnose thread starvation, deadlocks, and pool exhaustion from thread dumps under load.
- Design benchmarks that account for JIT warm-up and produce numbers worth acting on.
Target audience
- Senior Java engineers accountable for production performance
- Site reliability and platform engineers operating JVM workloads
- Application architects setting latency, capacity, and cost targets
- Performance engineers and load testing specialists
- Support engineers handling escalated production incidents
- Technical leads answerable for the infrastructure cost of Java services
Program outline
A clear structure for the learning journey.
Outline points are grouped in one designed block instead of being treated as separate module cards.
01JVM Internals and the Real Cost of an Object4 topics
- Runtime memory areas: heap, metaspace, thread stacks, and native memory
- Object layout, header size, and what an allocation actually costs
- JIT compilation tiers, inlining, and why early measurements mislead
- Escape analysis, deoptimization, and the limits of what the compiler can fix
02Garbage Collection Behaviour and Collector Selection4 topics
- Generational collection, regions, and how pause time is actually produced
- G1 tuning: region sizing, pause targets, and humongous allocations
- ZGC and low-latency collection: the cost in throughput and footprint
- Reading GC logs to separate a sizing problem from a genuine leak
03Memory Leaks and Heap Analysis4 topics
- Capturing heap dumps safely from a live production instance
- Dominator trees, retained size, and locating the object that holds memory
- Classic leak sources: caches, thread locals, listeners, and class loaders
- Off-heap and native memory growth that never appears in the heap
04Profiling with Flight Recorder and Mission Control4 topics
- Enabling continuous JFR recording at an overhead production can accept
- Reading CPU, allocation, and I/O profiles together rather than in isolation
- Event settings, custom events, and recording an incident as it happens
- Turning a profile into a ranked list of changes actually worth making
05Concurrency, Contention, and Thread Behaviour4 topics
- Thread dumps: deadlocks, blocked threads, and exhausted pools
- Lock contention, false sharing, and contended synchronization events
- Executor sizing, queue depth, and back pressure under sustained load
- Virtual threads: which workloads gain and which get measurably worse
06Benchmarking, Tuning Decisions, and Capacity4 topics
- JMH benchmarks that survive warm-up, dead-code elimination, and noise
- Latency percentiles, coordinated omission, and honest reporting to stakeholders
- Container limits, CPU shares, and JVM ergonomics under cgroups
- Recording a tuning decision so the team can revisit it with evidence
Materials provided
- Course workbook, annotated code samples, and reference notes
- Hands-on lab environment and starter repositories
- Exercises, checklists, and reusable code templates
- 4D Certificate of Completion
- Post-course technical guidance
Training Options
Programs can be delivered in-house, online, or in a blended format depending on your team's schedule, location, and learning objectives. When an external certificate or exam is included, certification rules and fees remain under the relevant awarding body's policies, while 4D provides the training and preparation support.
Why choose 4D
4D teaches this course on instrumented workloads instead of slides: participants deliberately induce leaks, contention, and pause-time regressions, then hunt them with the same tooling they will reach for at three in the morning. Where you can supply them, trainers work from your own GC logs and recordings so the tuning decisions leave the room already applied.
Related courses
Python Programming Fundamentals
A hands-on introduction to Python for engineers and analysts who need working code rather than tutorial fragments. Participants build fluency with data types, collections, functions, files, and error handling, then assemble a small program that reads real data and produces a usable report.
View courseIntermediate Python and Clean Code Practices
Designed for developers whose Python works but is difficult to change. The course covers dataclasses, generators, decorators, context managers, and type hints, then applies the refactoring moves that turn a nine-hundred-line module into small tested units guarded by black, ruff, and mypy.
View coursePython Automation and Scripting for Work Tasks
Aimed at teams losing hours every week to repetitive file, spreadsheet, and reporting work. Participants automate those tasks with Python: batch file handling, Excel and CSV processing, REST API calls, email alerts, and scheduled jobs that run unattended and report clearly when something fails.
View course