Java 25 ZGC Default — CPU Spike from Concurrent Marking

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