Java 19 

Java 19 is a non-LTS feature release following Java 18. It preceded Java 20 (March 2023). Java 19 reached end-of-life in March 2023 and receives no further updates. 

Java 19 Release Details 

Java 19 is end-of-life. Organizations running it should upgrade to a current LTS release: Java 21 or Java 25. 

Java 19 Language Features 

Record Patterns (Preview, JEP 405) 

First preview of record patterns, enabling destructuring of record components directly in instanceof and switch. Eliminates manual field extraction after pattern matching. 

// Before: manual field access 

if (obj instanceof Point p) { 

    int x = p.x(); 

    int y = p.y(); 

} 

// Java 19: record pattern destructuring 

if (obj instanceof Point(int x, int y)) { 

    System.out.println(x + y); 

} 

Finalized in Java 21 (JEP 440). 

Pattern Matching for switch (Third Preview, JEP 427) 

Third preview with refinements to pattern matching in switch. Replaced guarded patterns with parenthesized patterns. Previewed through Java 20, finalized in Java 21 (JEP 441). 

Java 19 API Changes 

Virtual Threads (Preview, JEP 425) 

First preview of virtual threads, lightweight threads managed by the JVM rather than the OS. Enables millions of concurrent tasks without thread pool tuning. Targeted at the thread-per-request programming model. 

// Before: platform thread (OS thread, expensive) 

new Thread(() -> handleRequest()).start(); 

// Java 19: virtual thread (JVM-managed, cheap) 

Thread.startVirtualThread(() -> handleRequest()); 

// Via ExecutorService 

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { 

    executor.submit(() -> handleRequest()); 

} 

Finalized in Java 21 (JEP 444). 

Foreign Function and Memory API (Preview, JEP 424) 

First preview (promoted from incubator). Replaces JNI with a safe, modern API for calling native functions and managing off-heap memory. Provides type-safe access to native memory without ByteBuffer or sun.misc.Unsafe. Finalized in Java 22 (JEP 454). 

Vector API (Fourth Incubator, JEP 426) 

Fourth incubation. Expresses vector computations that compile to optimal SIMD instructions on x86 (AVX) and ARM (NEON/SVE) processors. Still incubating as of Java 26 (JEP 529, tenth incubator). 

Structured Concurrency (Incubator, JEP 428) 

First incubator. Simplifies multithreaded programming by treating multiple concurrent tasks as a single unit of work. If one task fails, remaining tasks are cancelled. Eliminates thread leaks and race conditions from manual thread management. 

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { 

    Subtask<String> user = scope.fork(() -> fetchUser(id)); 

    Subtask<Order> order = scope.fork(() -> fetchOrder(id)); 

    scope.join(); 

    scope.throwIfFailed(); 

    return combine(user.get(), order.get()); 

} 

Promoted to preview in Java 21 (JEP 453), re-previewed in Java 23-25. 

Java 19 JVM Changes 

Linux/RISC-V Port (JEP 422) 

Ports the JDK to the Linux/RISC-V architecture. Supports the RVI20V64 ISA specification. Enables Java on RISC-V hardware including boards and emulators. 

Java 19 Upgrade Path 

Java 19 has been end-of-life since March 2023. Recommended upgrade targets: 

• Java 21 LTS: Adds virtual threads (final), record patterns (final), pattern matching for switch (final), generational ZGC, sequenced collections 

• Java 25 LTS: Current LTS. Adds scoped values, compact source files, AOT method profiling, compact object headers 

Java 19 applications should upgrade directly to Java 21 LTS rather than Java 20, which is also end-of-life. 

Azul’s Java 19 Support 

Azul Platform Core provides TCK-certified builds of current LTS releases with extended support. A single subscription covers all supported versions from Java 6 through Java 26.