Java 21 and What Comes Next

Why this matters

• Knowing which features are final and which are previews is the difference between a confident upgrade and an unpleasant surprise two releases later.
• Garbage collection improved more between 8 and 21 than in the decade before, and the right collector choice is usually a configuration change rather than a code change.
• A migration plan that sequences the work correctly takes days; one that does everything at once takes months.

What is final in Java 21

Garbage collection in 21

-XX:+UseG1GC                      # the default since Java 9 — balanced, tunable, good enough
-XX:+UseZGC -XX:+ZGenerational    # sub-millisecond pauses, generational since 21
-XX:+UseShenandoahGC              # low pause, an alternative to ZGC
-XX:+UseSerialGC                  # single-threaded — genuinely best for small containers
-XX:+UseParallelGC                # throughput-first, when pause length does not matter

# Measure before you tune — unified logging makes this easy
-Xlog:gc*:file=gc.log:time,uptime,level,tags

# Containers: let the JVM see the cgroup limits (default since Java 10)
-XX:MaxRAMPercentage=75

The previews worth understanding

Structured concurrency

// Preview in 21 and 22, changed in 23 — the shape is still settling
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Supplier<User> user = scope.fork(() -> loadUser(id));
    Supplier<Stats> stats = scope.fork(() -> loadStats(id));
    scope.join();
    scope.throwIfFailed();
    return new Dashboard(user.get(), stats.get());
}

The idea is that concurrent subtasks get a scope with a defined lifetime: if one fails the others are cancelled, and the scope cannot exit until all are finished. That turns concurrency into something a stack trace can describe. Use Executors.newVirtualThreadPerTaskExecutor() in production until this is final.

Scoped values

// Preview — the intended replacement for ThreadLocal with virtual threads
private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

ScopedValue.where(REQUEST_ID, id).run(() -> {
    handle();                       // anything called here can read REQUEST_ID
});

ThreadLocal is mutable, unbounded in lifetime, and inherited by child threads — all of which scale badly when there are a million threads. A scoped value is immutable and bounded to a dynamic scope, so it is cheap to propagate.

String templates

// Preview in 21 and 22, then withdrawn for redesign — do not build on this
// String message = STR."Hello \{name}, you have \{count} messages";

Foreign Function and Memory API

// Preview in 21, final in 22 — the replacement for JNI
try (Arena arena = Arena.ofConfined()) {
    MemorySegment segment = arena.allocate(1024);
    MethodHandle strlen = Linker.nativeLinker()
            .downcallHandle(SymbolLookup.loaderLookup().find("strlen").orElseThrow(),
                            FunctionDescriptor.of(JAVA_LONG, ADDRESS));
}

Calling native code and managing off-heap memory without writing C glue or using Unsafe. It became final in Java 22, so on a 21 baseline it needs --enable-preview.

Also in flight

// Project Valhalla — value classes, to remove the object header for small immutable types
// Project Babylon — code reflection, aimed at GPU and ML workloads
// Vector API — still an incubator module after many rounds, pending Valhalla

A migration path from 8 to 21

What to expect from the upgrade

Staying current after 21

Common misreadings

• "Everything in Java 21 is production-ready." Structured concurrency, scoped values and string templates were previews.
• "ZGC is always better than G1." It trades throughput for pause time. Stay on G1 until you measure a pause problem.
• "Preview features are stable enough." String templates were withdrawn entirely after two rounds.
• "You can run preview-compiled classes on a newer JDK." They are pinned to the exact version that compiled them.
• "Migrating means modularising." The classpath still works, and most applications stay on it.
• "Virtual threads replace CompletableFuture." They replace much of its use, not fan-out-and-combine composition.
• "The upgrade needs a code rewrite." Most of the benefit arrives with no code change at all.