What's New in Java 21

// JEP 440: Record Patterns
// Run: java RecordPatternsDemo.java

public class RecordPatternsDemo {

    enum Color { RED, GREEN, BLUE }

    record Point(int x, int y) {}
    record ColoredPoint(Point p, Color c) {}
    record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}

    // Before: type check -> cast -> accessor
    static int sumOld(Object obj) {
        if (obj instanceof Point) {
            Point p = (Point) obj;
            return p.x() + p.y();
        }
        return 0;
    }

    // Java 21: type check and deconstruction in one step
    static int sumNew(Object obj) {
        if (obj instanceof Point(int x, int y)) {
            return x + y;
        }
        return 0;
    }

    // Deconstruct nested records at once
    static Color upperLeftColor(Object obj) {
        if (obj instanceof Rectangle(ColoredPoint(Point p, Color c), ColoredPoint lr)) {
            return c;
        }
        throw new IllegalArgumentException("not a rectangle");
    }

    // switch + record patterns + when guards
    static String describe(Object obj) {
        return switch (obj) {
            case Point(int x, int y) when x == y -> "point on the diagonal (" + x + ", " + y + ")";
            case Point(int x, int y) -> "point (" + x + ", " + y + ")";
            case Rectangle(ColoredPoint(Point p, Color c), ColoredPoint lr) when c == Color.BLUE ->
                    "rectangle with a blue upper-left corner (x=" + p.x() + ")";
            case Rectangle r -> "rectangle";
            default -> "unknown";
        };
    }

    public static void main(String[] args) {
        Point point = new Point(1, 2);
        Rectangle blue = new Rectangle(
                new ColoredPoint(new Point(0, 0), Color.BLUE),
                new ColoredPoint(new Point(10, 10), Color.RED));
        Rectangle green = new Rectangle(
                new ColoredPoint(new Point(5, 5), Color.GREEN),
                new ColoredPoint(new Point(10, 10), Color.RED));

        System.out.println("sumOld(point)        = " + sumOld(point));
        System.out.println("sumNew(point)        = " + sumNew(point));
        System.out.println("upperLeftColor(blue) = " + upperLeftColor(blue));
        System.out.println("describe(Point(3,3)) = " + describe(new Point(3, 3)));
        System.out.println("describe(point)      = " + describe(point));
        System.out.println("describe(blue)       = " + describe(blue));
        System.out.println("describe(green)      = " + describe(green));
        System.out.println("describe(\"text\")     = " + describe("text"));
    }
}

// JEP 441: Pattern Matching for switch
// Run: java SwitchPatternDemo.java

public class SwitchPatternDemo {

    // Before: a chain of instanceof checks
    static String formatOld(Object o) {
        if (o instanceof Integer) {
            Integer i = (Integer) o;
            return "int " + i;
        } else if (o instanceof Long) {
            Long l = (Long) o;
            return "long " + l;
        } else if (o instanceof String) {
            String s = (String) o;
            return "String " + s;
        }
        return "unknown";
    }

    // Java 21: type patterns in case labels
    static String formatNew(Object o) {
        return switch (o) {
            case Integer i -> "int " + i;
            case Long l -> "long " + l;
            case String s -> "String " + s;
            default -> "unknown";
        };
    }

    // Before: without a null check first, switch throws NullPointerException
    static String answerOld(String s) {
        if (s == null) {
            return "Oops";
        }
        return switch (s) {
            case "YES", "NO" -> "Known";
            default -> "Other";
        };
    }

    // Java 21: handle it with case null
    static String answerNew(String s) {
        return switch (s) {
            case null -> "Oops";
            case "YES", "NO" -> "Known";
            default -> "Other";
        };
    }

    // when guards
    static String classify(Object o) {
        return switch (o) {
            case Integer i when i < 0 -> "negative integer";
            case Integer i when i == 0 -> "zero";
            case Integer i -> "positive integer";
            case String s when s.isBlank() -> "blank string";
            case String s -> "string (" + s.length() + " chars)";
            default -> "other";
        };
    }

    // With sealed types no default is needed (the compiler checks exhaustiveness)
    sealed interface Shape permits Circle, Square {}
    record Circle(double r) implements Shape {}
    record Square(double side) implements Shape {}

    static double area(Shape s) {
        return switch (s) {
            case Circle c -> Math.PI * c.r() * c.r();
            case Square q -> q.side() * q.side();
        };
    }

    public static void main(String[] args) {
        for (Object o : new Object[] {1, 2L, "abc", 3.14}) {
            System.out.printf("%-6s old=%-12s new=%s%n", o, formatOld(o), formatNew(o));
        }
        System.out.println("---");
        for (String s : new String[] {"YES", "yes", null}) {
            System.out.printf("%-5s old=%-6s new=%s%n", s, answerOld(s), answerNew(s));
        }
        System.out.println("---");
        for (Object o : new Object[] {-5, 0, 42, "  ", "Java", 1.0}) {
            System.out.printf("%-6s -> %s%n", "\"" + o + "\"", classify(o));
        }
        System.out.println("---");
        System.out.printf("area(Circle(1)) = %.4f%n", area(new Circle(1)));
        System.out.printf("area(Square(2)) = %.4f%n", area(new Square(2)));
    }
}

1      old=int 1        new=int 1
2      old=long 2       new=long 2
abc    old=String abc   new=String abc
3.14   old=unknown      new=unknown
---
YES   old=Known  new=Known
yes   old=Other  new=Other
null  old=Oops   new=Oops
---
"-5"   -> negative integer
"0"    -> zero
"42"   -> positive integer
"  "   -> blank string
"Java" -> string (4 chars)
"1.0"  -> other
---
area(Circle(1)) = 3.1416
area(Square(2)) = 4.0000

// JEP 443: Unnamed Patterns and Variables (preview in Java 21)
// Run: java --enable-preview --source 21 UnnamedVariablesDemo.java

import java.util.List;

public class UnnamedVariablesDemo {

    record Point(int x, int y) {}
    record Line(Point from, Point to) {}

    public static void main(String[] args) {
        // 1. Unused parts of a pattern
        Object obj = new Line(new Point(1, 2), new Point(3, 4));
        if (obj instanceof Line(Point(int x, _), _)) {
            System.out.println("x of the start point = " + x);
        }

        // 2. An unused loop variable
        int count = 0;
        for (var _ : List.of("a", "b", "c")) {
            count++;
        }
        System.out.println("number of elements = " + count);

        // 3. An unused exception variable
        try {
            Integer.parseInt("abc");
        } catch (NumberFormatException _) {
            System.out.println("not a number");
        }

        // 4. An unused lambda parameter
        List.of(1, 2, 3).forEach(_ -> System.out.print("*"));
        System.out.println();
    }
}

// JEP 430: String Templates (preview in Java 21, withdrawn in JDK 23)
// Run: java --enable-preview --source 21 StringTemplatesDemo.java

import java.text.MessageFormat;

public class StringTemplatesDemo {

    public static void main(String[] args) {
        String name = "xyz";
        int age = 18;

        String a = "Hello, " + name + "! Next year you'll be " + (age + 1) + ".";
        String b = new StringBuilder().append("Hello, ").append(name)
                .append("! Next year you'll be ").append(age + 1).append(".").toString();
        String c = String.format("Hello, %s! Next year you'll be %d.", name, age + 1);
        String d = MessageFormat.format("Hello, {0}! Next year you''ll be {1}.", name, age + 1);
        String e = STR."Hello, \{name}! Next year you'll be \{age + 1}.";

        System.out.println("+ operator    : " + a);
        System.out.println("StringBuilder : " + b);
        System.out.println("String.format : " + c);
        System.out.println("MessageFormat : " + d);
        System.out.println("STR           : " + e);

        // Works with text blocks too (any expression can be embedded)
        int x = 3, y = 4;
        String report = STR."""
                x = \{x}
                y = \{y}
                x * y = \{x * y}
                """;
        System.out.print(report);

        // Note: STR just concatenates the values (no escaping)
        String user = "' OR '1'='1";
        System.out.println(STR."SELECT * FROM users WHERE name = '\{user}'");
    }
}

+ operator    : Hello, xyz! Next year you'll be 19.
StringBuilder : Hello, xyz! Next year you'll be 19.
String.format : Hello, xyz! Next year you'll be 19.
MessageFormat : Hello, xyz! Next year you'll be 19.
STR           : Hello, xyz! Next year you'll be 19.
x = 3
y = 4
x * y = 12
SELECT * FROM users WHERE name = '' OR '1'='1'

// JEP 445: Unnamed Classes and Instance Main Methods (preview in Java 21)
// Run: java --enable-preview --source 21 InstanceMainDemo.java

// Fields and methods without a class declaration
String greeting = "Hello";

String greet(String name) {
    return greeting + ", " + name + "!";
}

void main() {
    System.out.println(greet("World"));
}

interface SequencedCollection<E> extends Collection<E> {
    SequencedCollection<E> reversed();
    default void addFirst(E e);
    default void addLast(E e);
    default E getFirst();
    default E getLast();
    default E removeFirst();
    default E removeLast();
}

interface SequencedSet<E> extends SequencedCollection<E>, Set<E> {
    SequencedSet<E> reversed();
}

interface SequencedMap<K, V> extends Map<K, V> {
    SequencedMap<K, V> reversed();
    default Map.Entry<K, V> firstEntry();
    default Map.Entry<K, V> lastEntry();
    default Map.Entry<K, V> pollFirstEntry();
    default Map.Entry<K, V> pollLastEntry();
    default V putFirst(K k, V v);
    default V putLast(K k, V v);
    default SequencedSet<K> sequencedKeySet();
    default SequencedCollection<V> sequencedValues();
    default SequencedSet<Map.Entry<K, V>> sequencedEntrySet();
}

// JEP 431: Sequenced Collections
// Run: java SequencedCollectionsDemo.java

import java.util.*;

public class SequencedCollectionsDemo {

    public static void main(String[] args) {
        list();
        deque();
        set();
        map();
        reversedIsView();
    }

    static void list() {
        System.out.println("=== List ===");
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2));
        // Before
        System.out.println("get(0) / get(size()-1) : " + list.get(0) + " / " + list.get(list.size() - 1));
        // Java 21
        System.out.println("getFirst() / getLast() : " + list.getFirst() + " / " + list.getLast());
        System.out.println("reversed()             : " + list.reversed() + "  original: " + list);
        // The old Collections.reverse modifies the list itself
        List<Integer> copy = new ArrayList<>(list);
        Collections.reverse(copy);
        System.out.println("Collections.reverse    : " + copy + "  (the copy itself was modified)");
    }

    static void deque() {
        System.out.println("=== Deque ===");
        Deque<Integer> deque = new ArrayDeque<>(List.of(0, 1, 2));
        // Before: reverse order through descendingIterator
        List<Integer> rev = new ArrayList<>();
        deque.descendingIterator().forEachRemaining(rev::add);
        System.out.println("descendingIterator     : " + rev);
        // Java 21
        System.out.println("reversed()             : " + deque.reversed() + "  original: " + deque);
    }

    static void set() {
        System.out.println("=== LinkedHashSet ===");
        LinkedHashSet<Integer> set = new LinkedHashSet<>(List.of(0, 1, 2));
        // Before: the only way to the last element is to loop to the end
        Integer last = null;
        for (Integer x : set) last = x;
        System.out.println("iterator().next() / loop : " + set.iterator().next() + " / " + last);
        // Java 21
        System.out.println("getFirst() / getLast()   : " + set.getFirst() + " / " + set.getLast());
        System.out.println("reversed()               : " + set.reversed());
        // Add at the front (an existing element moves to the front)
        set.addFirst(9);
        System.out.println("addFirst(9)              : " + set);
    }

    static void map() {
        System.out.println("=== LinkedHashMap ===");
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.putLast(0, "zero");
        map.putLast(1, "one");
        map.putLast(2, "two");
        System.out.println("map                    : " + map);
        System.out.println("firstEntry / lastEntry : " + map.firstEntry() + " / " + map.lastEntry());
        System.out.println("reversed()             : " + map.reversed());
        // An existing key moves to the front
        map.putFirst(1, "ONE");
        System.out.println("putFirst(1, \"ONE\")     : " + map);
        System.out.println("pollLastEntry()        : " + map.pollLastEntry() + "  remaining: " + map);
    }

    static void reversedIsView() {
        System.out.println("=== reversed() is a view ===");
        Deque<Integer> deque = new ArrayDeque<>(List.of(0, 1, 2));
        SequencedCollection<Integer> view = deque.reversed();
        // The front of the reversed view = the end of the original
        view.addFirst(9);
        System.out.println("after view.addFirst(9) : view=" + view + "  original=" + deque);
    }
}

=== List ===
get(0) / get(size()-1) : 0 / 2
getFirst() / getLast() : 0 / 2
reversed()             : [2, 1, 0]  original: [0, 1, 2]
Collections.reverse    : [2, 1, 0]  (the copy itself was modified)
=== Deque ===
descendingIterator     : [2, 1, 0]
reversed()             : [2, 1, 0]  original: [0, 1, 2]
=== LinkedHashSet ===
iterator().next() / loop : 0 / 2
getFirst() / getLast()   : 0 / 2
reversed()               : [2, 1, 0]
addFirst(9)              : [9, 0, 1, 2]
=== LinkedHashMap ===
map                    : {0=zero, 1=one, 2=two}
firstEntry / lastEntry : 0=zero / 2=two
reversed()             : {2=two, 1=one, 0=zero}
putFirst(1, "ONE")     : {1=ONE, 0=zero, 2=two}
pollLastEntry()        : 2=two  remaining: {1=ONE, 0=zero}
=== reversed() is a view ===
after view.addFirst(9) : view=[9, 2, 1, 0]  original=[0, 1, 2, 9]

// JEP 444: Virtual Threads - four ways to create a virtual thread
// Run: java VirtualThreadCreateDemo.java

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

public class VirtualThreadCreateDemo {

    public static void main(String[] args) throws Exception {
        Runnable task = () -> System.out.println("  " + Thread.currentThread());

        System.out.println("1. Thread.startVirtualThread");
        Thread.startVirtualThread(task).join();

        System.out.println("2. Thread.ofVirtual().name(...).start");
        Thread.ofVirtual().name("my-virtual").start(task).join();

        System.out.println("3. ThreadFactory");
        ThreadFactory factory = Thread.ofVirtual().name("worker-", 0).factory();
        Thread t = factory.newThread(task);
        t.start();
        t.join();

        System.out.println("4. Executors.newVirtualThreadPerTaskExecutor");
        // Leaving try-with-resources, close() waits for all tasks to finish
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.submit(task);
            executor.submit(task);
        }

        System.out.println("For comparison: a platform thread");
        Thread.ofPlatform().start(task).join();
        System.out.println("isVirtual = " + Thread.ofVirtual().unstarted(task).isVirtual());
    }
}

1. Thread.startVirtualThread
  VirtualThread[#23]/runnable@ForkJoinPool-1-worker-1
2. Thread.ofVirtual().name(...).start
  VirtualThread[#26,my-virtual]/runnable@ForkJoinPool-1-worker-1
3. ThreadFactory
  VirtualThread[#27,worker-0]/runnable@ForkJoinPool-1-worker-1
4. Executors.newVirtualThreadPerTaskExecutor
  VirtualThread[#28]/runnable@ForkJoinPool-1-worker-1
  VirtualThread[#29]/runnable@ForkJoinPool-1-worker-2
For comparison: a platform thread
  Thread[#31,Thread-0,5,main]
isVirtual = true

// JEP 444: Virtual Threads - run 4 virtual threads on 2 carrier threads and watch them mount / unmount
// Run: java VirtualThreadScheduleDemo.java

import java.time.Duration;
import java.util.concurrent.CountDownLatch;

public class VirtualThreadScheduleDemo {

    static final long START = System.nanoTime();

    // Executed in the order [compute ms, I/O ms, compute ms, ...]
    static final long[][] PLANS = {
            {2500, 500, 1000, 1500, 1300},
            {1800, 1000, 3800, 1500, 600},
            {2000, 500, 2500},
            {800, 500, 2800},
    };

    public static void main(String[] args) throws InterruptedException {
        // Limit the carrier threads to 2 (set before the first virtual thread is created)
        System.setProperty("jdk.virtualThreadScheduler.parallelism", "2");
        System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "2");

        CountDownLatch done = new CountDownLatch(PLANS.length);
        for (int i = 0; i < PLANS.length; i++) {
            int id = i + 1;
            long[] plan = PLANS[i];
            Thread.startVirtualThread(() -> {
                log(id, "start");
                for (int step = 0; step < plan.length; step++) {
                    if (step % 2 == 0) {
                        log(id, "compute " + plan[step] + " ms");
                        compute(plan[step]);
                    } else {
                        log(id, "I/O " + plan[step] + " ms (unmount)");
                        sleep(plan[step]);
                        log(id, "I/O done (remount)");
                    }
                }
                log(id, "done");
                done.countDown();
            });
        }
        done.await();
    }

    // Keep the CPU busy (the virtual thread stays mounted)
    static void compute(long ms) {
        long end = System.nanoTime() + ms * 1_000_000;
        double sink = 0;
        while (System.nanoTime() < end) {
            sink += Math.sqrt(sink + 1);
        }
    }

    // Stands in for blocking I/O (the virtual thread unmounts)
    static void sleep(long ms) {
        try {
            Thread.sleep(Duration.ofMillis(ms));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    static synchronized void log(int id, String message) {
        long elapsed = (System.nanoTime() - START) / 1_000_000;
        // toString() looks like "VirtualThread[#id]/state@carrier-thread-name"
        String carrier = Thread.currentThread().toString().replaceAll(".*@", "");
        System.out.printf("%5d ms  %-23s  VT-%d  %s%n", elapsed, carrier, id, message);
    }
}

    4 ms  ForkJoinPool-1-worker-2  VT-2  start
   12 ms  ForkJoinPool-1-worker-1  VT-1  start
   14 ms  ForkJoinPool-1-worker-1  VT-1  compute 2500 ms
   14 ms  ForkJoinPool-1-worker-2  VT-2  compute 1800 ms
 1817 ms  ForkJoinPool-1-worker-2  VT-2  I/O 1000 ms (unmount)
 1821 ms  ForkJoinPool-1-worker-2  VT-3  start
 1821 ms  ForkJoinPool-1-worker-2  VT-3  compute 2000 ms
 2515 ms  ForkJoinPool-1-worker-1  VT-1  I/O 500 ms (unmount)
 2516 ms  ForkJoinPool-1-worker-1  VT-4  start
 2517 ms  ForkJoinPool-1-worker-1  VT-4  compute 800 ms
 3317 ms  ForkJoinPool-1-worker-1  VT-4  I/O 500 ms (unmount)
 3318 ms  ForkJoinPool-1-worker-1  VT-2  I/O done (remount)
 3318 ms  ForkJoinPool-1-worker-1  VT-2  compute 3800 ms
 3821 ms  ForkJoinPool-1-worker-2  VT-3  I/O 500 ms (unmount)
 3822 ms  ForkJoinPool-1-worker-2  VT-1  I/O done (remount)
 3822 ms  ForkJoinPool-1-worker-2  VT-1  compute 1000 ms
 4823 ms  ForkJoinPool-1-worker-2  VT-1  I/O 1500 ms (unmount)
 4826 ms  ForkJoinPool-1-worker-2  VT-4  I/O done (remount)
 4826 ms  ForkJoinPool-1-worker-2  VT-4  compute 2800 ms
 7118 ms  ForkJoinPool-1-worker-1  VT-2  I/O 1500 ms (unmount)
 7119 ms  ForkJoinPool-1-worker-1  VT-3  I/O done (remount)
 7119 ms  ForkJoinPool-1-worker-1  VT-3  compute 2500 ms
 7627 ms  ForkJoinPool-1-worker-2  VT-4  done
 7627 ms  ForkJoinPool-1-worker-2  VT-1  I/O done (remount)
 7627 ms  ForkJoinPool-1-worker-2  VT-1  compute 1300 ms
 8928 ms  ForkJoinPool-1-worker-2  VT-1  done
 8928 ms  ForkJoinPool-1-worker-2  VT-2  I/O done (remount)
 8928 ms  ForkJoinPool-1-worker-2  VT-2  compute 600 ms
 9528 ms  ForkJoinPool-1-worker-2  VT-2  done
 9619 ms  ForkJoinPool-1-worker-1  VT-3  done

// JEP 444: Virtual Threads - limits of a thread pool vs virtual threads on a single carrier
// Run: java ThreadPoolVsVirtualDemo.java

import java.time.Duration;
import java.util.concurrent.*;

public class ThreadPoolVsVirtualDemo {

    static final long START = System.nanoTime();

    static void log(String message) {
        String thread = Thread.currentThread().isVirtual()
                ? "virtual@" + Thread.currentThread().toString().replaceAll(".*@", "")
                : Thread.currentThread().getName();
        System.out.printf("%5d ms  %-32s  %s%n", (System.nanoTime() - START) / 1_000_000, thread, message);
    }

    static Runnable task(int n) {
        return new Runnable() {
            public void run() {
                log("task " + n + " start");
                try {
                    Thread.sleep(Duration.ofSeconds(1));
                } catch (InterruptedException ignored) {
                }
                log("task " + n + " end");
            }

            public String toString() {
                return "task " + n;
            }
        };
    }

    public static void main(String[] args) throws Exception {
        System.out.println("=== 1. Fixed pool (1 thread), 5 tasks of 1 s ===");
        try (ExecutorService pool = Executors.newFixedThreadPool(1)) {
            for (int i = 0; i < 5; i++) pool.execute(task(i));
        }

        System.out.println("=== 2. Bounded queue (1 thread, queue of 2), 5 tasks ===");
        ThreadPoolExecutor bounded = new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(2),
                (r, executor) -> log("[REJECTED] " + r + " (queue is full)"));
        for (int i = 0; i < 5; i++) bounded.execute(task(i));
        bounded.shutdown();
        bounded.awaitTermination(10, TimeUnit.SECONDS);

        System.out.println("=== 3. Virtual threads (1 carrier), 5 tasks of 1 s ===");
        // Must be set before the first virtual thread is created
        System.setProperty("jdk.virtualThreadScheduler.parallelism", "1");
        System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 5; i++) executor.execute(task(i));
        }
    }
}

=== 1. Fixed pool (1 thread), 5 tasks of 1 s ===
    1 ms  pool-1-thread-1                   task 0 start
 1012 ms  pool-1-thread-1                   task 0 end
 1013 ms  pool-1-thread-1                   task 1 start
 2016 ms  pool-1-thread-1                   task 1 end
 2017 ms  pool-1-thread-1                   task 2 start
 3023 ms  pool-1-thread-1                   task 2 end
 3023 ms  pool-1-thread-1                   task 3 start
 4025 ms  pool-1-thread-1                   task 3 end
 4026 ms  pool-1-thread-1                   task 4 start
 5027 ms  pool-1-thread-1                   task 4 end
=== 2. Bounded queue (1 thread, queue of 2), 5 tasks ===
 5031 ms  pool-2-thread-1                   task 0 start
 5034 ms  main                              [REJECTED] task 3 (queue is full)
 5035 ms  main                              [REJECTED] task 4 (queue is full)
 6037 ms  pool-2-thread-1                   task 0 end
 6038 ms  pool-2-thread-1                   task 1 start
 7044 ms  pool-2-thread-1                   task 1 end
 7044 ms  pool-2-thread-1                   task 2 start
 8047 ms  pool-2-thread-1                   task 2 end
=== 3. Virtual threads (1 carrier), 5 tasks of 1 s ===
 8053 ms  virtual@ForkJoinPool-1-worker-1   task 0 start
 8055 ms  virtual@ForkJoinPool-1-worker-1   task 1 start
 8056 ms  virtual@ForkJoinPool-1-worker-1   task 2 start
 8057 ms  virtual@ForkJoinPool-1-worker-1   task 3 start
 8057 ms  virtual@ForkJoinPool-1-worker-1   task 4 start
 9060 ms  virtual@ForkJoinPool-1-worker-1   task 0 end
 9060 ms  virtual@ForkJoinPool-1-worker-1   task 1 end
 9061 ms  virtual@ForkJoinPool-1-worker-1   task 2 end
 9061 ms  virtual@ForkJoinPool-1-worker-1   task 3 end
 9062 ms  virtual@ForkJoinPool-1-worker-1   task 4 end

// JEP 444: Virtual Threads - 10,000 tasks that block for 1 s: fixed thread pool vs virtual threads
// Run: java ThroughputDemo.java

import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

public class ThroughputDemo {

    static void run(String label, ExecutorService executor) {
        long start = System.nanoTime();
        try (executor) {
            IntStream.range(0, 10_000).forEach(i -> executor.submit(() -> {
                Thread.sleep(Duration.ofSeconds(1));
                return i;
            }));
        }
        // close() waits for every task before we take the time
        System.out.printf("%-28s %6d ms%n", label, (System.nanoTime() - start) / 1_000_000);
    }

    public static void main(String[] args) {
        run("newFixedThreadPool(200)", Executors.newFixedThreadPool(200));
        run("newVirtualThreadPerTask", Executors.newVirtualThreadPerTaskExecutor());
    }
}

// JEP 444: Virtual Threads - memory per platform thread vs per virtual thread
// Run: java MemoryCostDemo.java

import com.sun.management.OperatingSystemMXBean;

import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class MemoryCostDemo {

    static final int PLATFORM_COUNT = 2_000;
    static final int VIRTUAL_COUNT = 200_000;

    public static void main(String[] args) throws Exception {
        System.out.println("Java " + System.getProperty("java.version")
                + ", " + Runtime.getRuntime().availableProcessors() + " CPU cores");
        measure("Platform", PLATFORM_COUNT, Thread.ofPlatform());
        measure("Virtual ", VIRTUAL_COUNT, Thread.ofVirtual());
    }

    static void measure(String label, int count, Thread.Builder builder) throws Exception {
        gc();
        long heapBefore = usedHeap();
        long osBefore = committedVirtualMemory();

        CountDownLatch ready = new CountDownLatch(count);
        CountDownLatch release = new CountDownLatch(1);
        List<Thread> threads = new ArrayList<>(count);
        for (int i = 0; i < count; i++) {
            threads.add(builder.start(() -> {
                ready.countDown();
                try {
                    // Keep every thread alive and waiting
                    release.await();
                } catch (InterruptedException ignored) {
                }
            }));
        }
        ready.await();
        gc();

        long heapDelta = usedHeap() - heapBefore;
        long osDelta = committedVirtualMemory() - osBefore;
        System.out.printf("[%s] %,d threads: heap +%s (%s each), OS committed virtual memory +%s (%s each)%n",
                label, count, format(heapDelta), format(heapDelta / count),
                format(osDelta), format(osDelta / count));

        release.countDown();
        for (Thread t : threads) t.join();
    }

    static long usedHeap() {
        return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
    }

    static long committedVirtualMemory() {
        var os = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
        return os.getCommittedVirtualMemorySize();
    }

    static void gc() throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            System.gc();
            Thread.sleep(300);
        }
    }

    static String format(long bytes) {
        if (Math.abs(bytes) < 1024) return bytes + " B";
        if (Math.abs(bytes) < 1024 * 1024) return String.format("%.2f KB", bytes / 1024.0);
        if (Math.abs(bytes) < 1024L * 1024 * 1024) return String.format("%.2f MB", bytes / 1024.0 / 1024);
        return String.format("%.2f GB", bytes / 1024.0 / 1024 / 1024);
    }
}

// JEP 444: Virtual Threads - what happens if you keep creating them without a limit
// Run: java -Xmx128m VirtualThreadOomDemo.java

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

public class VirtualThreadOomDemo {

    static volatile boolean outOfMemory = false;
    // Spare memory so that the result can still be printed
    static byte[] reserve = new byte[8 * 1024 * 1024];

    public static void main(String[] args) {
        // The OOM may happen inside a virtual thread, so detect it with a handler
        Thread.Builder builder = Thread.ofVirtual().uncaughtExceptionHandler((t, e) -> {
            if (e instanceof OutOfMemoryError) outOfMemory = true;
        });
        Runnable sleep10s = () -> {
            try {
                Thread.sleep(Duration.ofSeconds(10));
            } catch (InterruptedException ignored) {
            }
        };

        List<Thread> hold = new ArrayList<>();
        long start = System.nanoTime();
        try {
            while (!outOfMemory) {
                hold.add(builder.start(sleep10s));
            }
        } catch (OutOfMemoryError e) {
            outOfMemory = true;
        }
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        // Release the spare memory before printing
        reserve = null;
        System.out.printf("OutOfMemoryError after creating %,d threads (%,d ms)%n", hold.size(), elapsed);
    }
}

private static final Semaphore PERMITS = new Semaphore(50);

String callExternalApi() throws InterruptedException {
    PERMITS.acquire();
    try {
        return client.call();
    } finally {
        PERMITS.release();
    }
}

// JEP 444: Virtual Threads - pinning caused by synchronized (JDK 21-23)
// Run: java -Djdk.tracePinnedThreads=short PinningDemo.java

import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class PinningDemo {

    static void sleep1s() {
        try {
            Thread.sleep(Duration.ofSeconds(1));
        } catch (InterruptedException ignored) {
        }
    }

    // Run 2 tasks that block for 1 s while holding a lock (each task has its own lock, so there is no contention)
    static void run(String label, Runnable body) {
        long start = System.nanoTime();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.execute(body);
            executor.execute(body);
        }
        System.out.printf("%-14s %5d ms%n", label, (System.nanoTime() - start) / 1_000_000);
    }

    public static void main(String[] args) {
        // Use a single carrier thread to make the difference obvious
        System.setProperty("jdk.virtualThreadScheduler.parallelism", "1");
        System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");

        run("synchronized", () -> {
            Object lock = new Object();
            synchronized (lock) {
                // JDK 21: the carrier is pinned as well
                sleep1s();
            }
        });

        run("ReentrantLock", () -> {
            ReentrantLock lock = new ReentrantLock();
            lock.lock();
            try {
                // Can unmount
                sleep1s();
            } finally {
                lock.unlock();
            }
        });
    }
}

// JEP 446: Scoped Values (preview in Java 21)
// Run: java --enable-preview --source 21 ScopedValueDemo.java

import java.util.concurrent.StructuredTaskScope;

public class ScopedValueDemo {

    static final ThreadLocal<String> TL = new ThreadLocal<>();
    static final ScopedValue<String> SV = ScopedValue.newInstance();

    public static void main(String[] args) throws Exception {
        System.out.println("=== 1. ThreadLocal: a value you set stays from then on ===");
        TL.set("a");
        threadLocalFlow();
        TL.remove();

        System.out.println("=== 2. ScopedValue: the value exists only inside the scope ===");
        ScopedValue.where(SV, "a").run(ScopedValueDemo::scopedValueFlow);
        System.out.println("  outside the scope: isBound = " + SV.isBound());

        System.out.println("=== 3. The binding is immutable, but the object's contents are not ===");
        mutableObject();

        System.out.println("=== 4. Inherited automatically by StructuredTaskScope subtasks ===");
        inheritance();
    }

    static void threadLocalFlow() {
        System.out.println("  " + TL.get()); // a
        // If we overwrite it here...
        TL.set("b");
        System.out.println("  " + TL.get()); // b
        // ...callees keep seeing b too
        print();
    }

    static void print() {
        System.out.println("  " + TL.get());
    }

    static void scopedValueFlow() {
        System.out.println("  " + SV.get()); // a
        // b only inside the inner scope
        ScopedValue.where(SV, "b").run(() -> System.out.println("  " + SV.get()));
        // back to a after leaving it
        System.out.println("  " + SV.get());
    }

    // A deliberately mutable class
    static class Context {
        String name;
        Context(String name) { this.name = name; }
        public String toString() { return "Context{name=" + name + "}"; }
    }

    static final ScopedValue<Context> CTX = ScopedValue.newInstance();

    static void mutableObject() {
        ScopedValue.where(CTX, new Context("a")).run(() -> {
            System.out.println("  before: " + CTX.get());
            // Change the object's contents
            CTX.get().name = "b";
            System.out.println("  after : " + CTX.get() + "  <- visible to everyone in the same scope");
        });
    }

    static void inheritance() throws Exception {
        TL.set("REQ-123");
        ScopedValue.where(SV, "REQ-123").run(() -> {
            try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
                var a = scope.fork(() -> describe("fork-A"));
                var b = scope.fork(() -> describe("fork-B"));
                scope.join().throwIfFailed();
                System.out.println("  " + a.get());
                System.out.println("  " + b.get());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        TL.remove();
    }

    static String describe(String name) {
        return name + ": ScopedValue=" + SV.get() + ", ThreadLocal=" + TL.get();
    }
}

=== 1. ThreadLocal: a value you set stays from then on ===
  a
  b
  b
=== 2. ScopedValue: the value exists only inside the scope ===
  a
  b
  a
  outside the scope: isBound = false
=== 3. The binding is immutable, but the object's contents are not ===
  before: Context{name=a}
  after : Context{name=b}  <- visible to everyone in the same scope
=== 4. Inherited automatically by StructuredTaskScope subtasks ===
  fork-A: ScopedValue=REQ-123, ThreadLocal=null
  fork-B: ScopedValue=REQ-123, ThreadLocal=null

// JEP 453: Structured Concurrency (preview in Java 21)
// Run: java --enable-preview --source 21 StructuredConcurrencyDemo.java

import java.util.concurrent.*;
import java.util.function.Supplier;

public class StructuredConcurrencyDemo {

    static long t0;

    static void log(String message) {
        System.out.printf("%5d ms  %s%n", (System.nanoTime() - t0) / 1_000_000, message);
    }

    record User(String id, String name) {}
    record Order(String userId, int count) {}

    static User findUser(String id) throws InterruptedException {
        Thread.sleep(200);
        if (id.equals("bad")) throw new IllegalStateException("user not found");
        return new User(id, "Alice");
    }

    static Order fetchOrder(String id) throws InterruptedException {
        try {
            Thread.sleep(3_000);
            log("fetchOrder: finished");
            return new Order(id, 3);
        } catch (InterruptedException e) {
            log("fetchOrder: interrupted");
            throw e;
        }
    }

    // ExecutorService + Future (cancelling is the caller's job)
    static String withFuture(ExecutorService pool, String id) throws Exception {
        Future<Order> order = pool.submit(() -> fetchOrder(id));
        Future<User> user = pool.submit(() -> findUser(id));
        // Even if user fails, order keeps running
        return user.get().name() + " / " + order.get().count() + " orders";
    }

    // StructuredTaskScope.ShutdownOnFailure
    static String withScope(String id) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Supplier<Order> order = scope.fork(() -> fetchOrder(id));
            Supplier<User> user = scope.fork(() -> findUser(id));
            // If any subtask fails, interrupt the rest and throw
            scope.join().throwIfFailed();
            return user.get().name() + " / " + order.get().count() + " orders";
        }
    }

    // StructuredTaskScope.ShutdownOnSuccess: use only the first successful result
    static String fastest() throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            scope.fork(() -> { Thread.sleep(300); return "server A"; });
            scope.fork(() -> { Thread.sleep(100); return "server B"; });
            scope.fork(() -> { Thread.sleep(200); throw new IllegalStateException("server C is down"); });
            scope.join();
            return scope.result();
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("=== 1. Success ===");
        t0 = System.nanoTime();
        log("StructuredTaskScope: " + withScope("u1"));

        System.out.println("=== 2. findUser fails: ExecutorService + Future ===");
        t0 = System.nanoTime();
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            try {
                withFuture(pool, "bad");
            } catch (ExecutionException e) {
                log("caller: failure detected -> " + e.getCause().getMessage());
            }
        }
        // close() waits for the remaining tasks
        log("pool closed");

        System.out.println("=== 3. findUser fails: StructuredTaskScope ===");
        t0 = System.nanoTime();
        try {
            withScope("bad");
        } catch (ExecutionException e) {
            log("caller: failure detected -> " + e.getCause().getMessage());
        }
        log("scope closed");

        System.out.println("=== 4. Use the first success ===");
        t0 = System.nanoTime();
        log("result: " + fastest());
    }
}

=== 1. Success ===
 3011 ms  fetchOrder: finished
 3032 ms  StructuredTaskScope: Alice / 3 orders
=== 2. findUser fails: ExecutorService + Future ===
  207 ms  caller: failure detected -> user not found
 3006 ms  fetchOrder: finished
 3008 ms  pool closed
=== 3. findUser fails: StructuredTaskScope ===
  205 ms  fetchOrder: interrupted
  206 ms  caller: failure detected -> user not found
  206 ms  scope closed
=== 4. Use the first success ===
  107 ms  result: server B

// JEP 439: Generational ZGC
// Run (generational)    : java -XX:+UseZGC -XX:+ZGenerational -Xmx1g GenerationalZgcDemo.java
// Run (non-generational): java -XX:+UseZGC -Xmx1g GenerationalZgcDemo.java

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

public class GenerationalZgcDemo {

    public static void main(String[] args) {
        // Keep only the latest 50,000 objects (short-lived ones that soon become garbage)
        byte[][] recent = new byte[50_000][];
        // A small fraction lives until the end
        List<byte[]> longLived = new ArrayList<>();
        long start = System.nanoTime();

        for (int i = 0; i < 30_000_000; i++) {
            recent[i % recent.length] = new byte[1024];
            if (i % 500 == 0) longLived.add(new byte[1024]);
        }

        System.out.printf("allocated ~%d GB, long-lived %,d, elapsed %,d ms%n",
                30_000_000L * 1024 / 1024 / 1024 / 1024, longLived.size(), (System.nanoTime() - start) / 1_000_000);
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.printf("  %-20s count %4d, total %,6d ms%n", gc.getName(), gc.getCollectionCount(), gc.getCollectionTime());
        }
    }
}

java -XX:+UseZGC -XX:+ZGenerational -Xmx1g GenerationalZgcDemo.java
allocated ~28 GB, long-lived 60,000, elapsed 6,156 ms
  ZGC Minor Cycles     count   69, total  1,350 ms
  ZGC Minor Pauses     count  210, total      1 ms
  ZGC Major Cycles     count    9, total    587 ms
  ZGC Major Pauses     count   42, total      0 ms
java -XX:+UseZGC -Xmx1g GenerationalZgcDemo.java
allocated ~28 GB, long-lived 60,000, elapsed 7,203 ms
  ZGC Cycles           count   68, total  2,236 ms
  ZGC Pauses           count  204, total      2 ms