The Arrival of Java 19!

Follow Java and OpenJDK on Twitter.

Oracle is proud to announce the general availability of JDK 19. This release is the tenth Feature Release delivered on time through the six-month release cadence. This level of predictability allows developers to easily manage their adoption of innovation thanks to a steady stream of expected changes.

Chart showing number of features per release since Java 8

Java’s ability to boost performance, stability, and security continues to make it the world’s most popular programming language. According to an IDC report more than 10 million developers – representing 75% of full-time developers worldwide – use Java.

JDK 19 is now available!

Oracle now offers JDK 19 for developers, end-users, and enterprises. Oracle JDK 19 will receive performance, stability, and security updates following the Oracle Critical Patch Update (CPU) schedule as outlined in the Oracle Java SE Support Roadmap.

Oracle JDK 19 is not a long-term support (LTS) release. Oracle JDK 17 (announced on September 14, 2021) is the most recent long-term support (LTS) under the release cadence announced in 2018. Oracle has announced plans to shorten the time between future LTS releases, from 3 years to 2 years so you should expect the next LTS to be Java 21 in September of 2023.

Another important change announced with Oracle JDK 17 was the introduction of a new and simpler license terms which will allow companies to use Oracle JDK 17 – including the quarterly performance, stability, and security patches – at no cost for at least the next three years, allowing one full year of overlap with the next LTS release. Java SE subscribers get access to Oracle’s Java SE Support and commercial features such as GraalVM Enterprise, Java Management Service and the Advanced Management Console. See the New Java SE License Terms blog for details on the new license.

Java 19, Together

As with previous releases, with Java 19 we continue to celebrate the contributions from many individuals and organizations in the OpenJDK Community — we all build Java, together!

JDK 19 Fix Ratio

The rate of change over time in the JDK releases has remained largely constant for years, but under the six-month cadence the pace at which production-ready features and improvements are delivered has vastly improved.

Instead of making tens of thousands of fixes and delivering close to one hundred JEPs (JDK Enhancement Proposals) every few years as we did with yesteryear Major Releases, enhancements are delivered in leaner Feature Releases on a more manageable, predictable six-month schedule. The changes range from significant new features to small enhancements to routine maintenance, bug fixes, and documentation improvements. Each change is represented in a single commit for a single issue in the JDK Bug System.

Of the 19,297 JIRA issues marked as fixed in Java 11 through Java 19 at the time of their GA, 13,825 were completed by people working for Oracle while 5,472 were contributed by individual developers and developers working for other organizations. Going through the issues and collating the organization data from assignees results in the following chart of organizations sponsoring the development of contributions in Java: Going through the issues and collating the organization data from assignees results in the following chart of organizations sponsoring the development of contributions in Java:

Graph showing the number of fixes per organization

In Java 19, of the 1,962 JIRA issues marked as fixed, 1,383 were completed by Oracle, while 579 were contributed by other members of the Java community.

Oracle would like to thank the developers working for organizations including Alibaba, Amazon, ARM, Huawei, IBM, Intel, JetBrains, NTT Data, Red Hat, and Tencent for their notable contributions. We are also thankful to see contributions from smaller organizations such as Bellsoft, DataDog, Loongson, and Skymatic, as well as independent developers who collectively contributed 6% of the fixes in Java 19.

We are equally grateful to the many experienced developers who reviewed proposed changes, the early adopters who tried out early access builds and reported issues, and the dedicated professionals who provided feedback on the OpenJDK mailing lists.

The following individuals provided invaluable feedback on build quality, logged good quality bugs, or offered frequent updates:

  • Uwe Schindler (Apache Lucene)
  • Martin Grigorov (Apache Tomcat, Apache Wicket)
  • Rafael Winterhalter (Byte Buddy)
  • Yoann Rodière (Hibernate ORM, Validator, Search, Reactive)
  • Marc Hoffman (JaCoCo)
  • Lukas Eder (JOOQ)

Additionally, through the Quality Outreach program we would like to thank the following FOSS projects and individuals who provided excellent feedback on testing Java 19 early access builds to help improve the quality of the release:

  • Apache Derby (Rick Hillegas)
  • Apache Zookeeper (Enrico Olivelli)
  • BNYM Code Katas (Rinat Gatyatullin)
  • RxJava (David Karnok)
  • Apache Johnzon
  • JobRunr
  • MyBatis
  • Renaissance

New in Java 19

Along with thousands of performance, stability and security updates, Java 19 delivers delivers dozens of new features and enhancements, seven enhancements/changes rise to the level of being managed through the JDK Enhancement Proposals - JEPs process, including four preview features and two incubator features.

Some new features not requiring a JEP include new (D)TLS Signature Schemes, support for Unicode 14.0, additional DateTime formats and PAC-RET Protection on AArch64 systems. Full details of these and many other new features can be found at

JEP Preview Features are fully specified and fully implemented Language or VM Features of the Java SE Platform; and yet impermanent. They are made available in JDK Feature Releases to allow for developer feedback based on real-world uses, before them becoming permanent in a future release. This also affords tool vendors the opportunity to work towards supporting features before they are finalized into the Java SE Standard.

JEP Incubator modules allow putting non-final APIs and non-final tools in the hands of developers and users to gather feedback that will ultimately improve the quality of the Java platform.

The seven JEPs delivered with Java 19 are grouped into four categories mapping to key long-term Java technology projects and hardware support.

Project Amber

JEP 405 – Record Patterns (Preview)

Improves developer productivity by extending pattern matching to express more sophisticated, composable data queries. This is done by enhancing the Java programming language with record patterns to deconstruct record values. Record patterns and type patterns can be nested to enable a powerful, declarative, and composable form of data navigation and processing.

JEP 405 relates to:

  • [JDK 19] JEP 427: Pattern Matching for switch (3rd Preview)

JEP 427 – Pattern Matching for switch (3rd Preview)

Improves developer productivity by improving Java’s code semantics. This is done by enhancing the Java programming language with pattern matching for switch expressions and statements. Extending pattern matching to switch allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

JEP 427 relates to:

  • [JDK 17] JEP 406: Pattern Matching for switch (Preview)
  • [JDK 18] JEP 420: Pattern Matching for switch (2nd Preview)
  • [JDK 19] JEP 405: Record Patterns (Preview)

Project Panama

JEP 424 - Foreign Function & Memory API (Preview)

The Foreign Function & Memory API offers value in four unique ways:

Ease of use — Replaces the Java Native Interface (JNI) with a superior, pure-Java development model.

Performance — Provides performance that is comparable to, if not better than, existing APIs such as JNI and sun.misc.Unsafe.

Generality — Provides ways to operate on different kinds of foreign memory (e.g., native memory, persistent memory, and managed heap memory) and, over time, to accommodate other platforms (e.g., 32-bit x86) and foreign functions written in languages other than C (e.g., C++, Fortran).

Safety — Allows programs to perform unsafe operations on foreign memory but warn users about such operations by default.

The Foreign Function & Memory API introduces an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI.

JEP 424 relates to:

  • [JDK 18] JEP 419: Foreign Function & Memory API (2nd Incubator)
  • [JDK 17] JEP 412: Foreign Function & Memory API (Incubator)

JEP 426 - Vector API (4th Incubator)

Improves performance achieving performance superior to equivalent scalar computations. This is done by Introducing an API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPU architectures, thus achieving performance superior to equivalent scalar computations. Vector APIs were incubated in JDK 16, 17, and 18. JDK 19 incorporates feedback from users of those releases as well as performance improvements and implementation enhancements. It uses some of the Foreign Function and Memory APIs which are now mature enough to create this dependency.

JEP 426 relates to:

  • [JDK 16] JEP 338: Vector API (Incubator)
  • [JDK 17] JEP 414: Vector API (2nd Incubator)
  • [JDK 18] JEP 417: Vector API (3rd Incubator)

Project Loom

JEP 425 - JEP 425 - Virtual Threads (Preview)

Virtual Threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications.

Virtual Threads is the first JEP as part of Project Loom. Project Loom upgrades the Java concurrency model to meet the needs of today’s high-scale server applications.

There are a lot of great things about Java’s threads. They offer a natural programming model, with readable, sequential code using control flow operators that users understand – loops, conditionals, exceptions. Users get great debugging and serviceability, and readable stack traces. And threads are natural units of scheduling for OSes. We want to retain these advantages.

The problem is that the implementation of threads by the OS is too heavyweight. It takes too long to start a thread for each connection, but worse, the number of threads the OS can support at any one time limits the number of concurrent transactions a server can handle — to well below the capacity of the hardware or the network — and so threads become a severe constraining factor on server throughput.

Many people assumed we would embrace the asynchronous programming style offered by so-called “reactive” frameworks. By not representing concurrent operations directly as threads, it does scale beyond the limits posed by the thread-per-request model, but at a huge cost – much more complicated code that is harder to write, harder to read, and much harder to debug or profile because the platform in all its layers and its tools, is built around threads. Reactive may be the best people can do with the current JVM, but our goal is to do better, which we can do by making threads lighter and more scalable, letting developers keep using the model and tooling they’ve been using successfully for years.

Developers today have three bad options: waste hardware through underutilization, waste programmer effort with worse programming models and observability, or switch away from Java. So, Project Loom offers developers a better option.

Project Loom timeline:

  • Late 2017: Work on Loom begins
  • Jul 2019: EA build of Fiber prototype released for feedback
  • Sept 2019: JEP 353 (Reimplement Legacy Socket API) shipped in JDK 13
  • Sept 2020: JEP 373 (Reimplement Legacy DatagramSocket API) shipped in JDK 15
  • Nov 2021: Early Access builds of structured concurrency support released for feedback
  • Nov 2021: Draft JEPs for virtual threads and for structured concurrency published for comment
  • Mar 2022: JEP 418 (Internet Address Resolution SPI) shipped in JDK 18
  • Sep 2022: Preview in JDK 19

JEP 428 - Structured Concurrency (Incubator)

Structured Concurrency simplifies multithreaded programming by introducing an API for structured concurrency. This is done by simplifying multithreaded programming by introducing an API for structured concurrency. Structured concurrency treats multiple tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.

New Port

JEP 422 - Linux/RISC-V Port Ports the JDK to the Linux/RISC-V architecture. RISC-V is a free and open-source RISC instruction set architecture (ISA) designed originally at the University of California, Berkeley, and now developed collaboratively under the sponsorship of RISC-V International. It is already supported by a wide range of language toolchains. With the increasing availability of RISC-V hardware, a port of the JDK offers value to developers.


Java continues to be the #1 programming language for today’s technology trends. As the on-time delivery of improvements with Java 19 demonstrates, through continued thoughtful planning and ecosystem involvement, the Java platform is well-positioned for modern development and growth in the cloud.

Continue staying current with news and updates by:

  • Visiting (Oracle’s dedicated portal to advance your Java knowledge and community participation).
  • Visiting (news and views by the Java Team at Oracle).
  • Listening to the podcasts (an audio show for Java Developers brought to you directly from the people that make Java at Oracle. Conversations will discuss the language, the JVM, OpenJDK, platform security, innovation projects like Loom and Panama, and everything in between).
  • Watching Newscasts (a video show extending the Inside.Java podcast into a video format).
  • Watching Java on YouTube (Oracle’s collection of relevant Java videos to help grow your Java expertise).
  • Joining the OpenJDK mailing lists (the place to learn about the progress of your favorite OpenJDK projects).
  • Following OpenJDK and Java on Twitter (social streams offering updates and news on the continual evolution of Java).
  • Reading Java Magazine; Oracle’s digital Java publication offering technical articles by developers for developers

JavaOne is back!

With the continued delivery of Java technology innovation, Oracle is proud to bring back JavaOne, the premiere Java developer conference. The reintroduction of JavaOne is a testament to Oracle’s commitment towards its technology leadership and community stewardship.

During this year’s conference, attendees will be able to immerse themselves in multiple Java 19 related sessions along with content spanning the depth and breadth of technology topics related to the Java language and platform, cloud, database, AI and machine learning, tooling, DevOps, Java Card and more.

For a limited time, developers can use the “INSIDEJAVA” promotion code to receive $400.00 (USD) discount on the retail price. We’re looking forward to seeing you at this year’s event. Register now: