What’s New in Java 19: Virtual Threads and Pattern Matching

Published: March 12, 2023

Java 19 arrived with exciting previews that continue to evolve the language and platform towards more expressive, performant, and developer-friendly features. Two of the most talked-about enhancements are Virtual Threads (Project Loom preview) and expanded Pattern Matching capabilities.

In this post, we’ll dive into these features, their motivations, practical examples, and how you can start experimenting with them today.

1. Virtual Threads (Preview)

Java has traditionally relied on OS threads for concurrency. While powerful, OS threads are costly to create and manage, limiting scalability in highly concurrent applications such as web servers or messaging systems.

Virtual Threads — introduced as a preview in Java 19 — are lightweight threads managed by the JVM rather than the OS. They allow you to write concurrent code in a familiar thread-per-task style but with dramatically less overhead.

Why Virtual Threads?

Lightweight: Millions of virtual threads can be created with minimal resource usage.
Simplifies concurrency: No need for complex async programming models like reactive streams.
Improves scalability: Better utilization of CPU and memory for IO-bound workloads.

Example: Using Virtual Threads

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

public class VirtualThreadExample {
  public static void main(String[] args) throws InterruptedException {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
      for (int i = 0; i < 10; i++) {
        final int task = i;
        executor.submit(() -> {
          System.out.println("Running task " + task + " on thread " + Thread.currentThread());
          try {
            Thread.sleep(1000); // simulate blocking IO
          } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
          }
          System.out.println("Completed task " + task);
        });
      }
      // Executor will auto-close and wait for tasks to complete
    }
  }
}

Output:

Running task 0 on thread VirtualThread[#1,main,5]
Running task 1 on thread VirtualThread[#2,main,5]
...
Completed task 0
Completed task 1
...

Notice how each task runs in its own virtual thread without heavy resource cost.

How to Enable Virtual Threads?

Since this is a preview feature, you need to enable it explicitly with:

java --enable-preview -jar yourapp.jar

or, if running from the command line:

javac --enable-preview --release 19 VirtualThreadExample.java
java --enable-preview VirtualThreadExample

2. Pattern Matching Enhancements

Java has steadily introduced pattern matching to simplify and make type checks more concise and readable. Java 19 builds on this with further enhancements, such as pattern matching for switch expressions.

Pattern Matching with instanceof (Refresher)

Before pattern matching:

if (obj instanceof String) {
  String s = (String) obj;
  System.out.println(s.toUpperCase());
}

With pattern matching:

if (obj instanceof String s) {
  System.out.println(s.toUpperCase());
}

New: Pattern Matching for switch (Preview)

Java 19 introduces preview support for using patterns in switch expressions, enabling more expressive, concise conditional logic.

static String formatterPatternSwitch(Object o) {
  return switch (o) {
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> o.toString();
  };
}

Why This Matters for Developers

Virtual Threads open doors for simple, scalable concurrency without complex async code, ideal for web apps, microservices, and batch jobs.
Pattern Matching in switch enhances code clarity and reduces boilerplate in decision-making logic.
Both features help write cleaner, more maintainable Java code aligned with modern programming paradigms.

How to Get Started?

Download and install JDK 19 (or newer) from Oracle or OpenJDK.
Enable preview features for compiling and running code.
Experiment with virtual threads in IO-heavy applications to observe performance gains.
Refactor existing instanceof and switch statements to use pattern matching for readability.

Summary

Feature	Status	Key Benefits
Virtual Threads	Preview	Lightweight concurrency, simple async code
Pattern Matching in switch	Preview	Cleaner control flow with type-safe patterns

Java 19 sets the stage for modern concurrency and more expressive syntax, building momentum towards upcoming releases like Java 20 and beyond.

If you want, I can prepare posts covering Java 20 and later, including Project Loom’s finalization and other exciting features. Would you like that?