Java Academy · Lesson

Identifying Bottlenecks

Measure before optimizing.

Identifying Bottlenecks is a free Java Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Java Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Measure, Don't Guess

The first rule of performance work: measure before you optimize.

Intuition about where a Java program spends its time is usually wrong. The JIT compiler, garbage collector, and caching all defeat hand-waving. Profile, find the real hotspot, fix that.

A Bottleneck Defined

A bottleneck is the part of the system that limits overall throughput or latency.

Optimizing anything else gives no visible benefit. Amdahl's Law makes this precise: if 90% of time is in one method, speeding up the other 10% can never give more than an 11% improvement.

Latency vs Throughput

Decide what you are optimizing:

Latency — how long one request takes.
Throughput — how many requests per second.

They trade off. Batching improves throughput but can raise per-request latency. Know your target before tuning.

Wall Clock Timing

The crudest measurement is wall-clock time around a block of code with System.nanoTime().

It is useful for a quick sanity check, but it includes JIT warmup, GC pauses, and OS scheduling noise, so treat single numbers with suspicion.

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        long sum = 0;
        for (int i = 0; i < 10_000_000; i++) sum += i;
        long elapsed = System.nanoTime() - start;
        System.out.println("Sum: " + sum);
        System.out.println("Elapsed ms: " + (elapsed / 1_000_000.0));
    }
}

Beware JIT Warmup

Java starts interpreting bytecode, then the JIT compiles hot methods to native code.

So the first runs of a method are far slower than later runs. A naive timing loop measures mostly warmup. Real benchmarks warm up first, then measure steady state — which is exactly what JMH does for you.

CPU-Bound vs IO-Bound

Classify the bottleneck:

CPU-bound — threads are busy computing; cores are saturated.
IO-bound — threads wait on disk, network, or the database.

Profilers separate these as 'on-CPU' versus 'blocked/waiting' time. The fix differs completely: faster algorithms vs more concurrency or fewer round trips.

Sampling vs Instrumentation

Two profiling strategies:

Sampling — periodically capture stack traces. Low overhead, statistical.
Instrumentation — inject counters into every method. Exact, but heavy and can distort timings.

For production, prefer low-overhead sampling like Java Flight Recorder.

Memory as a Bottleneck

Often the real cost is allocation, not computation. Excess object churn triggers frequent garbage collection, stealing CPU and adding pauses.

Watch allocation rate and GC time. Reducing allocations in a hot loop frequently beats micro-tuning the arithmetic.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Allocation-heavy: a new String each iteration
        List<String> garbage = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            garbage.add("item-" + i);
        }
        System.out.println("Allocated " + garbage.size() + " strings");
        System.out.println("In a hot loop, this churn drives GC pressure");
    }
}

Find the Top of the Stack

A sampling profiler produces a list of methods ranked by how often they appeared on a CPU stack — the self time.

The method at the top is your candidate. But confirm it is on the critical path: a hot method that runs in a background logger may not affect user-facing latency.

Establish a Baseline

Before changing anything, record a baseline measurement under realistic load.

After each change, re-measure and compare. Without a baseline you cannot prove an optimization helped — and many 'optimizations' make things worse. Change one thing at a time.

Profile Under Realistic Load

A bottleneck found on an idle laptop may not be the one that hurts in production.

Use representative data sizes and concurrency.
Reproduce the workload that actually matters to users.

Synthetic micro-tests can point you at a method that is irrelevant at scale. Profile where the pain really is.

Quick Check

Why are single, naive System.nanoTime() timings of a Java method often misleading?

Recap

Finding bottlenecks the disciplined way:

Measure before optimizing; intuition lies.
Pick a goal: latency or throughput.
Classify CPU-bound vs IO-bound; watch GC/allocation.
Prefer low-overhead sampling profilers.
Beware JIT warmup; establish a baseline and change one thing at a time.

Frequently asked questions

Is the “Identifying Bottlenecks” lesson free?

Yes — the full text of “Identifying Bottlenecks” is free to read here on the web, and the Java Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Java Academy course, upgrade to CoddyKit PRO.

What will I learn in “Identifying Bottlenecks”?

Measure before optimizing. You practise Java Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Java Academy?

No prior experience is required. Java Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Identifying Bottlenecks” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Java Academy lesson?

Yes. Every Java Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Java Academy