Virtual Threads (official version) significantly simplifies high-throughput concurrent programming, suitable for I/O-intensive tasks; 2. Structured Concurrency (official version) improves the readability and security of concurrent code and avoids zombie threads; 3. String Templates (preview version) replaces String.format, making it safer to verify when compiling; 4. Sequenced Collections API (official version) unified and ordered collection operations such as getFirst and reversed; 5. Other new additions include Scoped Values, Record Patterns and General ZGC. It is recommended to upgrade to Java 21 as soon as possible for performance improvements and modern syntax support, especially for I/O-intensive applications and new concurrent logic development.

Java 21, released in September 2023, is a long-term support (LTS) version — meaning it's not just another incremental update. It brings powerful new features, performance improvements, and long-awaited language enhancements that developers have been asking for. If you're upgrading from Java 17 (also LTS), here's what's actually new and useful in Java 21.

? 1. Virtual Threads (Preview → Final)

This is the biggest game-changer in Java 21 — and it's no longer in preview! Virtual threads make writing high-throughput concurrent applications dramatically easier.

Why it matters:

• Traditional platform threads (OS threads) are expensive — limited in number and heavy on memory.
• Virtual threads are lightweight , managed by the JVM, and can scale to millions per process.
• You don't need to rewrite your code — just use Thread.startVirtualThread(Runnable) or run your existing ExecutorService tasks on a virtual thread factory.

Example:

 try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1)); // No blocking issues!
            System.out.println("Task " i " done");
            return null;
        });
    });
}
// Runs fast, no thread pool tuning needed

Tip: Use virtual threads for I/O-heavy tasks (web servers, DB calls, APIs) — not CPU-bound work.

? 2. Structured Concurrency (Final)

Complements virtual threads by making concurrent code easier to reason about and debug.

What it does:

• Groups related threads into a single unit of work.
• Ensures all child threads complete or fail together — no more "zombie threads".
• Catches exceptions cleanly and propagates them to the caller.

Example:

 try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> fetchUser());
    Future<Integer> score = scope.fork(() -> fetchScore());

    scope.join(); // Wait for both
    scope.throwIfFailed(); // Propagate any exception

    return new Result(user.resultNow(), score.resultNow());
}

Think of it like try-with-resources for concurrency — clean, predictable, and safe.

? 3. String Templates (Preview)

A modern alternative to String.format() and concatenation — think of it as “f-strings for Java”.

Why you'll like it:

• Safer than String.format() (no runtime errors from mismatched args).
• More readable than or StringBuilder .
• Supports interpolated expressions with compile-time validation.

Example:

 String name = "Alice";
int score = 95;

// Old way
String msg = String.format("User %s scored %d", name, score);

// New way with STR template
String msg = STR."User \{name} scored \{score}";

Also supports raw templates ( FMT ) for formatting:

 double price = 19.99;
String formatted = FMT."Price: \{price,.2f}"; // "Price: 19.99"

Still in preview — but likely to become standard soon.

? 4. Sequenced Collections API (Final)

Adds consistent methods like getFirst() , getLast() , and reversed() to all ordered collections.

Before Java 21:

 List<String> list = new ArrayList<>();
String last = list.get(list.size() - 1); // Ugly

After Java 21:

 List<String> list = new ArrayList<>();
String first = list.getFirst();
String last = list.getLast();
SequencedCollection<String> reversed = list.reversed();

Works with List , Deque , and any collection that has a defined encounter order.

? 5. Other Notable Additions

• Scoped Values (Preview): Safer alternative to thread-local variables — especially useful with virtual threads.
• Record Patterns (Final): Simplify destructuring records in instanceof or switch .
• Pattern Matching for switch (Final): Match on types, records, and more inside switch expressions.
• General ZGC (Experimental): Improves GC pause times by separating young/old objects — great for latency-sensitive apps.

? What Should You Do Now?

• ? Upgrade to Java 21 — especially if you're on Java 17 or earlier.
• ? Start using virtual threads in I/O-heavy apps — huge perf gains with minimal code changes.
• ? Try string templates in new code — they're more readable and less error-prone.
• ? Use structured concurrency for any new async logic — it makes debugging easier.

Java 21 isn't just about new syntax — it's about making concurrency simple, safe, and scalable . These features reduce boilerplate, improve performance, and make Java feel modern again.

Basically, if you're writing Java in 2024 , Java 21 is where you want to be.

The above is the detailed content of What's New in Java 21: A Comprehensive Guide. For more information, please follow other related articles on the PHP Chinese website!