Java 25 ZGC Default — CPU Spike from Concurrent Marking

A few weeks ago, Mojang announced Minecraft Java Edition 26.1 requires Java 25. Developers asked: why this version, and what's in it?

Turns out, quite a lot. Java 25 is an LTS release — same category as Java 11, 17, and 21. Non-LTS releases (22, 23, 24) are fine for experimentation, but nobody runs production workloads on them.

This article covers what Java 25 actually changes. Honest takes on what matters and what's mostly marketing.

First — What Is an LTS Release and Why Does It Matter?

Java ships a new version every 6 months. Most of these are short-term releases — supported for 6 months and then dropped. LTS (Long-Term Support) releases are different — they get security patches and bug fixes for years.

This is why Minecraft waited. They weren't going to require Java 22 and then have to require Java 25 a year later. They skipped straight to the LTS.

For your own projects, the practical takeaway is simple: if you're on Java 21, start planning an upgrade. Java 17's LTS support ends in 2026.

Complete JEP Reference Table for Java 25

Here is the full list of Java Enhancement Proposals (JEPs) that shipped in JDK 25. Use this as a quick reference to understand what each change delivers.

This table is the authoritative source; each JEP links to the specification page on OpenJDK. For migration, focus on the Final JEPs — Preview features are unstable and subject to change.

LTS Feature Progression: Java 17 → Java 21 → Java 25

Understanding the feature progression across the last three LTS releases helps you plan your upgrade journey. Here's a side-by-side comparison of the most impactful language and JVM changes.

Key trend: each LTS release doubles down on concurrency and memory efficiency. Java 25 is the first where the default GC is latency-optimised, and object overhead is automatically reduced.

Removals and Deprecations in Java 25

Every Java release removes or deprecates old APIs. Java 25 is no exception. Here is the definitive list of what you must account for when migrating.

Fully removed in Java 25: - finalize() method — removed. Use Cleaner or AutoCloseable instead. The @Deprecated(since="9", forRemoval=true) tag finally acted on. - Security Manager — permanently disabled (JEP 486). Calling System.setSecurityManager() throws UnsupportedOperationException. - Port of the BSD kernel (x86-32) — removed (JEP 479). No more 32-bit macOS/BSD support. - Legacy File-based URL constructors — removed. Use URI.toURL(). - java.rmi activation framework — removed (deprecated in Java 15).

Deprecated in Java 25 (likely removed in future): - -XX:+UseAdaptiveSizePolicy (G1GC only) — no effect; to be removed. - -Xlog:gc=info format may change; migrate to structured logging via -Xlog:gc:file=.... - ThreadGroup stop/resume/suspend — deprecated for removal. - java.security.Policy — deprecated, use modular security.

Module system changes: - java.se.ee module removed (already removed from JDK 9+? Actually java.se.ee was removed in 11. For 25, no further removal). - But note: The java.corba module was removed in 11; java.xml.ws in 11. In 25, no additional module removals. - The jdk.unsupported module still exists for internal APIs (e.g., sun.misc.Unsafe) but use is strongly discouraged. - JNI restrictions are warned (JEP 472); future releases may enforce encapsulation.

Run jdeprscan on your codebase to identify deprecated API usage before upgrading.

Java 21 to Java 25 Migration Guide

Migrating from Java 21 to Java 25 is intentionally low-friction, but there are areas that need attention. Follow this guide step by step.

1. Check build tool compatibility - Maven: use maven-compiler-plugin:3.13.0+ (supports Java 25). - Gradle: upgrade to 8.10+ (supports Java 25 toolchain).

2. Remove preview flags - Remove --enable-preview from javac flags if you were using Pattern Matching for switch or Record Patterns in preview. They are now final. - Remove -XX:+UseZGC if present (it's default).

3. Handle removed APIs - Replace finalize() with Cleaner (example below). - Replace System.setSecurityManager(...) with a custom access control or remove entirely. - Check for sun.* internal API usage: jdeprscan --for-removal --class-path ....

4. Test GC behaviour - Run with ZGC default. If CPU usage is >20% higher, tune -XX:ConcGCThreads or revert to G1GC. - Verify compact object headers work: java -d64 -version (64-bit required). - Check that heap metrics improve: jcmd <pid> GC.heap_info.

5. Update module-info if needed - No new module restrictions in Java 25, but if you used --add-exports for sun.misc.Unsafe, those still work (deprecated). - Consider migrating to java.lang.foreign (MemorySegment) for off-heap operations.

6. Validate virtual thread workloads - Ensure no pinned threads due to synchronized blocks; replace with ReentrantLock. - Avoid large ThreadLocal data; use Scoped Values (preview) if appropriate.

7. Run a full regression test - Compile and run tests with Java 25. Use --release 25 in javac. - Deploy to a staging environment and monitor CPU, memory, and latency for 48 hours.

Breaking changes (rare but real): - Custom sun.misc.Cleaner implementations may break due to internal changes. - java.lang.Compiler is removed (already in Java 9? Actually removed in Java 9, but check). - javax.security.auth.Policy is removed (replaced by sun.security.provider.PolicyFile? note only deprecated).

Sample Cleaner migration: ```java // Before (removed) @Override protected void finalize() { cleanup(); }

// After private final Cleaner cleaner; private final Cleaner.Cleanable cleanable;

public MyResource() { cleaner = Cleaner.create(); cleanable = cleaner.register(this, () -> cleanup()); } ```

# Step-by-step migration commands
sdk install java 25-tem
sdk default java 25-tem

cd your-project
./mvnw clean test -Djava.version=25 -Dmaven.compiler.release=25

# Check for deprecated API usage
jdeprscan --for-removal --class-path target/classes

# Verify GC is ZGC
java -XX:+PrintFlagsFinal -version | grep UseZGC

# Check compact headers (only on 64-bit)
java -d64 -version

ZGC Is Now the Default GC — This One Actually Matters

This is the change most developers will feel without changing a single line of code. Up until Java 25, the default garbage collector was G1GC. G1 is good — but it has stop-the-world pauses. For most apps this is fine. For latency-sensitive apps (game servers, trading systems, real-time APIs), those pauses are a problem.

ZGC keeps pauses under 1 millisecond regardless of heap size. It does this by doing most of its work concurrently — while your application is still running. Minecraft's chunk loading used to cause noticeable lag spikes because G1GC would kick in during heavy world generation. ZGC smooths that out.

The best part: you don't have to do anything. No JVM flags, no config changes. If you were already using -XX:+UseZGC, you can remove that flag.

package io.thecodeforge.monitoring;

import java.lang.management.ManagementFactory;
import java.lang.management.GarbageCollectorMXBean;
import java.util.List;

/**
 * Verify which garbage collector your JVM is using.
 */
public class GCChecker {
    public static void main(String[] args) {
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        
        System.out.println("--- TheCodeForge Runtime Monitor ---");
        System.out.println("Active Garbage Collectors for this JVM instance:");
        
        for (GarbageCollectorMXBean bean : gcBeans) {
            System.out.printf(" - %s (Collections: %d, Total Time: %dms)%n", 
                bean.getName(), 
                bean.getCollectionCount(), 
                bean.getCollectionTime());
        }
    }
}

ZGC vs G1GC vs Shenandoah: Performance Comparison

With Java 25 defaulting to ZGC, you have three modern GCs to choose from. Here's a direct comparison to help you decide for your workload.

When to choose which: - ZGC: Latency-critical apps, large heaps, unpredictable allocation patterns. - G1GC: Throughput-oriented batch jobs, moderate-heap apps, CPU-limited environments. - Shenandoah: Low-pause requirement but willing to trade more CPU than ZGC; often used in large-scale web servers.

Shenandoah is not the default in any OpenJDK build (Oracle, Temurin). It must be enabled explicitly: -XX:+UseShenandoahGC. It is available in Amazon Corretto and Red Hat builds.

Compact Object Headers — Less RAM, Same Code

Every Java object carries a header — JVM bookkeeping data. In Java 21 and earlier, this is typically 96 to 128 bits. Java 25 ships compact object headers (JEP 450) as a stable feature, cutting that down to 64 bits.

Now 32 bits doesn't sound like a lot. But a typical backend application might have tens of millions of live objects. Across that many objects, you're looking at a meaningful drop in heap usage — less GC pressure, better cache locality, and lower cloud bills.

# Production Dockerfile for Java 25 applications
# We use the Temurin distribution for stable LTS support
FROM eclipse-temurin:25-jdk-jammy

WORKDIR /app
COPY target/forge-service.jar app.jar

# Pro-tip: Java 25 automatically optimizes object headers on 64-bit systems.
# You can verify this in logs by adding -Xlog:cds=debug during startup.
ENTRYPOINT ["java", "-Xmx2g", "-jar", "app.jar"]

Pattern Matching for switch — Finally Out of Preview

This one has been in preview since Java 17. Four release cycles later, it's fully finalised in Java 25 — which means it's stable, won't change, and you can use it without --enable-preview.

If you've written a lot of instanceof chains, you'll like this.

package io.thecodeforge.logic;

public class ShapeProcessor {
    // Sealed hierarchy ensures the switch is exhaustive at compile-time
    public sealed interface Shape permits Circle, Rectangle, Triangle {}
    public record Circle(double radius) implements Shape {}
    public record Rectangle(double width, double height) implements Shape {}
    public record Triangle(double base, double height) implements Shape {}

    public static double calculateArea(Shape shape) {
        return switch (shape) {
            case Circle c    -> Math.PI * Math.pow(c.radius(), 2);
            case Rectangle r -> r.width() * r.height();
            case Triangle t  -> 0.5 * t.base() * t.height();
            // Default is unnecessary and actually discouraged with sealed types!
        };
    }

    public static String categorizeInput(Object obj) {
        return switch (obj) {
            case Integer i when i > 100 -> "High-capacity Integer";
            case Integer i -> "Standard Integer";
            case String s when s.isBlank() -> "Empty input string";
            case String s -> "Valid string: " + s;
            case null -> "Null reference detected";
            default -> "Unsupported type";
        };
    }
}

Record Patterns — Destructure in One Line

Also finalised in Java 25. Record patterns let you unpack record components directly inside a pattern match — no separate accessor calls needed.

package io.thecodeforge.models;

public class PatternDemo {
    record Point(int x, int y) {}
    record Window(Point topLeft, Point bottomRight) {}

    public static void printDiagnostics(Object obj) {
        // Nesting record patterns for deep destructuring
        if (obj instanceof Window(Point(int x1, int y1), Point(int x2, int y2))) {
            int width = Math.abs(x2 - x1);
            int height = Math.abs(y2 - y1);
            System.out.printf("Rendering Window [%dx%d] starting at (%d,%d)%n", width, height, x1, y1);
        }
    }
}

Virtual Threads Are Stable — Use Them

Virtual threads were finalised in Java 21, but Java 25 fixes a bunch of edge cases that made people hesitant to use them in production — particularly around thread-local variables and synchronisation with native code.

If you're running a web server and still using a fixed thread pool, switch to virtual threads. The code change is one line.

package io.thecodeforge.web;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrencyConfig {
    
    /**
     * Returns an executor that spawns a new virtual thread for every task.
     * Ideal for blocking I/O operations like database queries or REST calls.
     */
    public static ExecutorService getVirtualExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }

    public void handleAsyncRequest(Runnable task) {
        // Lightweight thread creation
        Thread.ofVirtual()
              .name("forge-worker-", 1)
              .start(task);
    }
}

So Why Did Minecraft Really Upgrade?

Three reasons, honestly:

ZGC by default — chunk loading in large worlds triggered G1GC pauses that players felt as lag. ZGC's sub-millisecond pauses remove that.

Compact object headers — Minecraft tracks millions of blocks, entities, and chunks simultaneously. Cutting header size reduces baseline memory pressure, which is why Mojang could confidently bump the default launcher RAM to 4GB without it feeling wasteful.

It's LTS — Mojang isn't going to build on a release that's out of support in 6 months. Java 25 takes them through to 2030. Same reason they were on Java 21 before this.

There's also a fourth, less talked-about reason: Java 25 is the first version to fully unobfuscate the Minecraft codebase under the new release process. But that's more of an internal tooling story than a Java feature story.

How to Actually Upgrade

The migration from Java 21 to Java 25 is low-friction for most projects. There are no major breaking API changes.

# 1. Install Java 25 (Temurin) via SDKMAN
sdk install java 25-tem
sdk default java 25-tem

# 2. Update your Maven pom.xml
# <properties>
#   <java.version>25</java.version>
#   <maven.compiler.release>25</maven.compiler.release>
# </properties>

# 3. Or update your Gradle build.gradle
# java {
#     toolchain {
#         languageVersion = JavaLanguageVersion.of(25)
#     }
# }

# 4. Clean and verify
./mvnw clean verify

Why Java 25 Matters — The Real Reason You Should Care

Oracle’s latest LTS isn’t just another version bump. Java 25 fixes real production pain points we’ve been duct-taping for years.

Compact object headers mean your 16GB heap now holds 20-30% more objects without changing a single line of code. ZGC becomes the default GC — less tuning, fewer pause-time surprises. Virtual threads finally graduate from preview, so you can stop wrestling with thread pools for I/O-bound workloads.

This is the first LTS where Oracle actually listened to what breaks in production. The focus is on reducing memory overhead, simplifying concurrency, and eliminating boilerplate with mature pattern matching. If you’re still on Java 17 or 21, you’re leaving performance on the table — and paying for it in cloud bills.

// io.thecodeforge — java tutorial
// Demonstrating compact object header memory savings in Java 25

public class HeapSavingsDemo {
    // A typical POJO we see in microservices
    record OrderItem(String productId, int quantity, double price) {}

    public static void main(String[] args) {
        var items = new OrderItem[1_000_000];
        for (int i = 0; i < items.length; i++) {
            items[i] = new OrderItem("SKU-" + i, i % 10, 19.99 + i);
        }
        
        Runtime rt = Runtime.getRuntime();
        long used = rt.totalMemory() - rt.freeMemory();
        System.out.println("Heap used for 1M OrderItem records: " + used / 1024 / 1024 + " MB");
    }
}

Step 1: Go to the Official Downloads Page — Avoid the Scrap Sites

Open a browser and navigate to oracle.com/java/technologies/downloads. Scroll until you see 'Java SE Development Kit 25'.

Do not download from third-party mirrors or 'fast download' sites. They wrap installers with adware, bundle outdated versions, or worse. Oracle’s site is the single source of truth.

You’ll see three Windows options: .exe installer, .msi installer, and a compressed archive. For 99% of developers, grab the .exe. The .msi is for enterprise deployment tools. The archive is for Docker images or CI runners where you want no system-level install.

// io.thecodeforge — java tutorial
// Quick sanity check after download

public class VersionCheck {
    public static void main(String[] args) {
        String version = System.getProperty("java.version");
        String vendor = System.getProperty("java.vendor");
        
        System.out.println("Java Version: " + version);
        System.out.println("Vendor: " + vendor);
        
        // Expected for legit Oracle JDK 25:
        if (version.startsWith("25") && vendor.contains("Oracle")) {
            System.out.println("✅ Authentic JDK 25 from official source");
        }
    }
}

Oracle Training and Professional Certification — The Real Career Accelerator

You've been reading about ZGC and pattern matching. Cool. But when the layoffs come, nobody cares if you know Compact Object Headers. They care if you can prove you know Java. That's where Oracle certification matters.

The Java SE 25 certification path validates you can actually build production systems, not just read blog posts. It covers the stuff that breaks in prod: memory model, concurrency, garbage collection tuning. The exam is hard — it should be. If you can pass it, you're worth the salary.

Don't confuse free tutorials with professional certs. Tutorials teach you syntax. Certification teaches you why that syntax exists and when to avoid it. Oracle's official training gives you the vocabulary to argue with architects. Get certified before your next job hop — it pays for itself in the first offer letter.

// io.thecodeforge — java tutorial

// The difference between tutorial code and cert-level code
class TransactionProcessor {
    // Junior: works on localhost
    void process(String raw) {
        var data = raw.split(",");  // No error handling
        System.out.println(data[0]); 
    }

    // Senior (what certification tests): thread-safe, bounded
    void processSafe(String raw) {
        if (raw == null || raw.isBlank()) {
            throw new IllegalArgumentException("Payload required");
        }
        // Virtual threads + structured concurrency
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            var validated = scope.fork(() -> validate(raw));
            scope.join();
            System.out.println(validated.get());
        } catch (Exception e) {
            System.err.println("Cert-level handling: " + e.getMessage());
        }
    }
    private String validate(String s) { return s.trim(); }
}

Creating Graphical User Interfaces — Java Still Owns Desktop

Web devs laugh at desktop Java. Let them. While they're chasing the next React framework, you're shipping native-performance GUI apps that run without a browser, without Node, without Docker. JavaFX is alive and well in Java 25 — no more Swing legacy pain.

JavaFX gives you hardware-accelerated rendering, CSS styling, and a scene graph that doesn't leak memory like Electron. Financial trading floors, medical imaging, and industrial control panels all run JavaFX. Why? Because it works when the network is down.

Oracle still maintains JavaFX as part of the JDK. You get FXML for layout, binding for reactive updates, and WebView if you must embed HTML. The learning curve is shallow if you know Java — it's just objects and events. Build a dashboard that polls your microservices. No Electron bloat. No 200MB download. Just a JAR file that runs.

// io.thecodeforge — java tutorial

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class SimpleDashboard extends Application {
    @Override
    public void start(Stage stage) {
        var cpuLabel = new Label("CPU: —");
        var memLabel = new Label("MEM: —");

        // Simulate live updates (real code uses Timer + Platform.runLater)
        cpuLabel.setText("CPU: 32%");
        memLabel.setText("MEM: 1.2GB / 8GB");

        var root = new VBox(10, cpuLabel, memLabel);
        var scene = new Scene(root, 300, 100);
        stage.setTitle("Prod Dashboard — Java 25");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Vector API — JEP 508 (Tenth Incubator)

Vector computations let you process multiple data points with a single CPU instruction, known as SIMD (Single Instruction, Multiple Data). Java 25 brings the tenth incubator of the Vector API, still under JEP 508. Why this matters: mainstream Java workloads—machine learning inference, cryptography, signal processing, compression—crunch arrays of numbers. Without the Vector API, you rely on the JIT compiler to auto-vectorize loops, which often fails for complex patterns. This API gives you explicit control to write portable vectorized code that maps directly to CPU instructions like AVX-512 or NEON. The incubator status means the API keeps refining based on real-world usage. Performance gains can be 2x to 10x for hot loops. You write a FloatVector species, define an operation like add, and the JVM translates it to hardware intrinsics. No more hand-tuned assembly or platform-specific intrinsics libraries.

// io.thecodeforge — java tutorial

import jdk.incubator.vector.*;

public class VectorAddExample {
    public static void main(String[] args) {
        float[] a = {1, 2, 3, 4, 5, 6, 7, 8};
        float[] b = {8, 7, 6, 5, 4, 3, 2, 1};
        float[] c = new float[8];

        var species = FloatVector.SPECIES_256;
        for (int i = 0; i < a.length; i += species.length()) {
            var va = FloatVector.fromArray(species, a, i);
            var vb = FloatVector.fromArray(species, b, i);
            va.add(vb).intoArray(c, i);
        }

        System.out.println(java.util.Arrays.toString(c));
    }
}

JFR CPU-Time Profiling (JEP 509 — Experimental)

JFR (JDK Flight Recorder) already records events like thread sleeps, GC pauses, and lock contention—but it never sampled actual CPU time consumed by running code. Java 25 introduces experimental CPU-Time Profiling via JEP 509. Why this changes profiling: traditional wall-clock sampling tells you a method was active, but not whether it was actually computing or just waiting for I/O. CPU-time profiling attributes samples to methods based on consumed CPU cycles, not elapsed time. This isolates hot compute-heavy methods from idle ones. You enable it with -XX:StartFlightRecording:name=cpuprofile,cputime=true. The output is identical to regular JFR recordings, so existing tools like JDK Mission Control work without changes. This helps find genuine CPU bottlenecks hiding behind I/O wait or lock contention in your Java services. Expect production-safe overhead—less than 1%—because sampling leverages signal-based interrupt handlers.

// io.thecodeforge — java tutorial

// Run your app with CPU-time profiling enabled in JFR
// java -XX:StartFlightRecording:name=cpuprofile,cputime=true,dumponexit=true,filename=profile.jfr YourApp

// Example: simple CPU-heavy loop
public class CpuProfileLaunch {
    public static void main(String[] args) {
        double sum = 0;
        for (int i = 0; i < 10_000_000; i++) {
            sum += Math.sin(i) * Math.cos(i);
        }
        System.out.println("Sum: " + sum);
    }
}

Ahead-of-Time Command-Line Ergonomics (JEP 514 — Final)

Building a custom JDK runtime image with jlink used to require juggling dozens of obscure flags. Java 25 finalizes JEP 514, which brings sane defaults and simpler command-line options for Ahead-of-Time (AOT) compilation and linking. Why this matters: developers avoided jlink because the configuration overhead was high. Now, jlink automatically selects reasonable compression, no more manual --strip-debug flags unless you want them. The jlink command also detects your target OS and architecture without extra flags. For AOT compilation, jaotc gains a --output option that deduces file extension from the module name. These changes lower the barrier to creating small, optimized runtime images—critical for containerized deployments where image size and startup time matter. You can now produce a 30MB JDK image with a single command, instead of wrestling with six flags. The ergonomics follow the principle: the common case should be the default.

// io.thecodeforge — java tutorial

// Before Java 25 (verbose, error-prone)
// jlink --module-path $JAVA_HOME/jmods --add-modules java.base --output myapp-runtime --strip-debug --compress=2

// Java 25 (sensible defaults)
jlink --add-modules java.base,java.management --output myapp-runtime

// Verify image size
du -sh myapp-runtime
// Typically ~25-30MB for minimal image