JDK 21 Features
📚 Table of Contents
- What is JDK 21
- Why JDK 21 Matters
- Virtual Threads (Project Loom)
- Structured Concurrency
- Scoped Values
- Pattern Matching for Switch (Final)
- Record Patterns
- Sequenced Collections
- String Templates (Preview)
- Summary
- Interview Questions
🤔 What is JDK 21?
JDK 21 is a Long-Term Support (LTS) release of Java.
👉 That means:
- It will be supported for years
- Production-ready features
- Major improvements in concurrency and language design
💡 Why JDK 21 is Important
Before JDK 21:
⚠️ Threads were expensive
⚠️ Async code was complex (CompletableFuture hell 😅)
⚠️ Pattern matching was limited
JDK 21 fixes these problems in a very elegant way.
🧵 1. Virtual Threads (Project Loom)
This is the biggest feature.
👉 Problem
Traditional threads (platform threads):
- Heavyweight
- Limited (~thousands max)
- Expensive context switching
👉 Solution
Virtual Threads:
- Lightweight
- Managed by JVM, not OS
- You can create millions of them
🧠 Internal Working
👉 Virtual threads are scheduled by the JVM using carrier threads (actual OS threads)
Think of it like:
- Many virtual threads → mapped onto few OS threads
- JVM handles scheduling instead of OS
✅ Example
public class VirtualThreadExample {
public static void main(String[] args) throws Exception {
Runnable task = () -> {
System.out.println("Running in: " + Thread.currentThread());
};
Thread.startVirtualThread(task);
Thread.sleep(1000);
}
}
👉 Output shows something like:
VirtualThread[#21]/runnable@ForkJoinPool
🔥 Real Use Case
Handling thousands of API calls:
try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10000; i++) {
executor.submit(() -> {
System.out.println("Task executed by: " + Thread.currentThread());
});
}
}
💡 No more thread pool tuning headache.
🧵 2. Structured Concurrency (Preview)
This feature changes how we manage parallel tasks.
👉 Problem
When multiple threads run:
- Hard to manage lifecycle
- Error handling becomes messy
👉 Solution
Structured Concurrency groups tasks together.
🧠 Internal Idea
👉 Treat multiple threads like a single unit of work
If one fails:
- Cancel others
- Propagate error cleanly
✅ Example
import java.util.concurrent.*;
public class StructuredConcurrencyExample {
public static void main(String[] args) throws Exception {
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future<String> task1 = scope.fork(() -> "Result 1");
Future<String> task2 = scope.fork(() -> "Result 2");
scope.join();
scope.throwIfFailed();
System.out.println(task1.resultNow());
System.out.println(task2.resultNow());
}
}
}
💡 Cleaner than CompletableFuture chains.
🔐 3. Scoped Values (Preview)
👉 Problem
ThreadLocal:
- Hard to manage
- Memory leaks risk
- Debugging nightmare
👉 Solution
Scoped Values provide immutable thread-bound data
🧠 Internal Concept
👉 Values are:
- Immutable
- Bound to execution scope
- Automatically cleaned
✅ Example
import java.lang.ScopedValue;
public class ScopedValueExample {
static final ScopedValue<String> USER = ScopedValue.newInstance();
public static void main(String[] args) {
ScopedValue.where(USER, "Amit").run(() -> {
System.out.println(USER.get());
});
}
}
💡 Much safer than ThreadLocal.
🔄 4. Pattern Matching for Switch (Final)
Finally stable 🎉
👉 Before
if (obj instanceof String) {
String s = (String) obj;
}
👉 Now
static void test(Object obj) {
switch (obj) {
case String s -> System.out.println("String: " + s);
case Integer i -> System.out.println("Integer: " + i);
default -> System.out.println("Unknown");
}
}
🧠 Internal Benefit
👉 Compiler ensures:
- Exhaustiveness
- Type safety
- Less casting
📦 5. Record Patterns
Records become even more powerful.
✅ Example
record Person(String name, int age) {}
public class RecordPatternExample {
static void print(Object obj) {
if (obj instanceof Person(String name, int age)) {
System.out.println(name + " is " + age);
}
}
}
💡 Direct destructuring of objects.
📚 6. Sequenced Collections
Finally, Java standardizes order-aware collections.
👉 New Interfaces
- SequencedCollection
- SequencedSet
- SequencedMap
✅ Example
import java.util.*;
public class SequencedExample {
public static void main(String[] args) {
SequencedCollection<String> list = new ArrayList<>();
list.add("A");
list.add("B");
System.out.println(list.getFirst());
System.out.println(list.getLast());
}
}
🧠 Why It Matters
👉 Before:
- No consistent way to access first/last
👉 Now:
- Unified API across collections
🧪 7. String Templates (Preview)
Safer and cleaner string building.
👉 Problem
String query = "SELECT * FROM users WHERE id = " + userId;
⚠️ Risk of injection
String name = "John";
String message = STR."Hello \{name}";
🧠 Internal Idea
👉 Template processors validate and transform strings safely.
✅ Summary
JDK 21 is not just an upgrade — it’s a shift.
👉 Key takeaways:
- Virtual Threads → Massive scalability
- Structured Concurrency → Cleaner parallel code
- Scoped Values → Safer context handling
- Pattern Matching → Better readability
- Record Patterns → Simpler data handling
- Sequenced Collections → Consistent APIs
- String Templates → Safer string operations
🎯 Interview Questions
1. What are Virtual Threads?
👉 Lightweight threads managed by JVM for high scalability.
2. Difference between Virtual Thread and Platform Thread?
👉 Virtual → JVM managed
👉 Platform → OS managed
3. What is Structured Concurrency?
👉 Managing multiple tasks as a single unit.
4. Why Scoped Values over ThreadLocal?
👉 Immutable, safer, no memory leaks.
5. What is Pattern Matching in switch?
👉 Type-based branching with automatic casting.
6. What are Record Patterns?
👉 Destructuring objects directly in conditions.
7. What are Sequenced Collections?
👉 Collections with defined ordering operations.