Insights and updates on Java SE and OpenJDK from the Java Platform Group Product Management Team

  • March 18, 2020

The Arrival of Java 14!

Sharat Chander
Director, Java SE Product Management

Follow OpenJDK on Twitter

Download Oracle OpenJDK

Download Oracle JDK

Oracle is proud to announce the general availability of Java 14 representing the fifth feature release as part of the six-month cadence.  This level of predictability, for over two years now, allows developers to more easily manage their adoption of innovation thanks to a steady stream of expected changes.

Java 14 is now available!

Oracle now offers Java 14 for all developers and enterprises.  Oracle JDK 14 will receive a minimum of two quarterly updates, per the Oracle Critical Patch Update (CPU) schedule, before being followed by Oracle JDK 15. Java 15 will reach general availability on September 2020, but early access builds are already being offered at jdk.java.net.

Once again, Oracle provides Java 14 as the Oracle OpenJDK release using the open source GNU General Public License v2, with the Classpath Exception (GPLv2+CPE), and also under a commercial license for those using the Oracle JDK release as part of an Oracle product or service, or for those who prefer commercial licenses over open source licenses. 

Java 14, Together

Similar to Java 11, Java 12, and Java13, we continue to celebrate the contributions made to Java 14 from many individuals and organizations in the OpenJDK Community — we all build Java, together!

JDK 14 Fix Ratio

The overall rate of change over time in the JDK has remained essentially constant for many years, but under the six-month cadence the pace at which production-ready innovations are delivered has vastly improved. Instead of making tens of thousands of fixes and around one hundred JDK Enhancement Proposals (JEPs) available in a large major release every few years, enhancements are delivered in smaller feature releases on a more manageable, predictable six-month schedule. These changes can range from a significant feature 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 1,986 JIRA issues marked as fixed in JDK 14, 1,458 were completed by people working for Oracle while 528 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 fixes in JDK 14:

Oracle would like to thank the developers working for organizations, like ARM, Google, NTT Data, Red Hat, and SAP for their notable contributions.  We are also thankful to see contributions from smaller organizations such as Bellsoft, Loongson, and independent developers who collectively contributed 3% of the fixes in JDK 14.

We would also like to acknowledge and thank 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. 

We greatly appreciate the contributions of the following individuals for providing useful feedback on build quality:

  • Jaikiran Pai (representing Apache Ant)
  • Uwe Schindler (representing Apache Lucene)
  • Mark Thomas (representing Apache Tomcat)
  • Martin Grigorov (representing Apache Wicket)
  • Nikhil Nanivadekar (representing Eclipse Collections)
  • Sanne Grinovero (representing Hibernate)
  • Evegney Madrikov (representing JaCoCo)
  • Dávid Karnok (representing RxJava)

And we’re also thankful to the following contributors who logged quality bugs & offered frequent updates:

  • Andriy Redko (representing Apache CXF)
  • Martin Grigorov (representing Apache Wicket)
  • Nikhil J. Nanivadekar (representing Eclipse Collections)  
  • Marc Hoffmann (representing JaCoCo)

New in Java 14

Java 14 offers users sixteen main enhancements/changes, including two incubator modules, three preview features, two deprecated features, and two removals.

Some enhancements are introduced in Incubator modules, a means of putting non-final APIs and non-final tools in the hands of developers that allows users to offer feedback that can ultimately improve the quality of the Java platform.

Similarly, some enhancements are introduced as Preview Features, language or VM features of the Java SE Platform that are fully specified, fully implemented, and yet impermanent. They are available in a JDK feature release to provoke developer feedback based on real-world use, which may lead to them becoming permanent in a future release.  This offers users the chance to provide timely feedback, as well as allowing tool vendors the opportunity to build support for the feature before the bulk of Java developers use it in production.

Finally, some changes are intended to reduce the size and scope of the JDK via Deprecation, which is a technique to communicate information about the life-cycle of an API: to encourage applications to migrate away from the API, to discourage applications from forming new dependencies on the API, and to inform developers of the risks of continuing dependence upon the API.  With the jdeprscan tool, first introduced in Java 9, users can perform static analysis of their jar files (or some other aggregation of class files) to identify uses of deprecated API elements, thus allowing them to prepare in-advance for their future removal.

The 16 JEPs delivered with JDK 14 are:

  1. JEP 305 - Pattern Matching for instanceof (Preview): This preview feature enhances Java with pattern matching for the instanceof operator.  This improves developer productivity by eliminating the need for common boiler plate code and allows more concise type-safe code.
  2. JEP 343 - Packaging Tool (Incubator): This incubator tool provides a way for developers to package Java applications for distribution in platform-specific formats.  The tool helps developers with modern applications where constraints require runtimes and applications to be bundled in a single deliverable.
  3. JEP 345 - NUMA-Aware Memory Allocation for G1: This feature improves overall performance of the G1 garbage collector on Non-uniform memory access (NUMA) systems.
  4. JEP 349 - JFR Event Streaming: This feature exposes JDK Flight Recorder (JFR) data for continuous monitoring, which will simplify access to JFR data to various tools and applications.
  5. JEP 352 - Non-Volatile Mapped Byte Buffers: This feature adds a file mapping mode for the JDK when using non-volatile memory.  The persistent nature of non-volatile memory changes various persistence and performance assumptions which can be leveraged with this feature.
  6. JEP 358 - Helpful NullPointerExceptions: This feature improves the usability of NullPointerExceptions by describing precisely which variable was null and other helpful information.  This will improve developer productivity and improve the quality of many development and debugging tools.
  7. JEP 359 - Records (Preview): This preview feature provides a compact syntax for declaring classes which hold shallowly immutable data.  Superficially, this feature greatly reduces boilerplate code in classes of this type, but ultimately its goal is to better allow the modeling of data as data.  It should be easy, clear, and concise to declare shallowly-immutable nominal data aggregates.
  8. JEP 361 - Switch Expressions: This was a preview feature in JDK 12 and JDK 13 and is now a completed feature.  It allows switch to be used as either a statement or an expression.  This feature simplifies every day coding and prepared the way for the pattern matching (JEP 305) feature previewed in this release.
  9. JEP 362 - Deprecate the Solaris and SPARC Ports: This JEP deprecates the Solaris and SPARC ports with the intent to remove them in a future release. 
  10. JEP 363 - Remove the Concurrent Mark Sweep (CMS) Garbage Collector: The CMS garbage collector was deprecated over two years ago and G1, which has been the intended successor to CMS since JDK 6, has been the default GC and used at scale for many years.  We have also seen the introduction of two new collectors, ZGC and Shenandoah, along with many improvements to G1 over the same time. 
  11. JEP 364 - ZGC on macOS: While most users that require ZGC also require the scalability of Linux-based environments, it is also often needs, for deployment and testing, in Windows and macOS.  There are also certain desktop applications which will benefit from ZGC capabilities.  Therefore, the ZGC feature was ported to Windows and macOS.
  12. JEP 365 - ZGC on Windows: Please reference the summary for JEP 364.
  13. JEP 366 - Deprecate the ParallelScavenge + SerialOld GC Combination: This deprecates the combination of the Parallel Scavenge and Serial Old garbage collection algorithms, which is rarely used, with the intent to remove it in a future release.
  14. JEP 367 - Remove the Pack200 Tools and API: This removes the pack200 and unpack200 tools, and the Pack200 API in the java.util.jar package. These tools and API were deprecated for removal in Java SE 11.
  15. JEP 368 - Text Blocks (Second Preview): After receiving feedback when Text Blocks was first introduced as a preview feature (JEP 355) as part of Java 13, two new escape sequences have been added, and Text Blocks is being offered as a preview feature for a second time. Benefits of Text Blocks include: simplified writing of programs using strings that span several lines of source code, while avoiding escape sequences in common cases; enhanced readability of strings in Java programs that denote code written in non-Java languages; supports the migration from string literals by stipulating that any new construct can express the same set of strings as a string literal, interpret the same escape sequences, and be manipulated in the same ways as a string literal.
  16. JEP 370 - Foreign-Memory Access API (Incubator): This incubator module introduces an API to allow Java programs to safely and efficiently access foreign memory outside of the Java heap.

Tooling Support

Current and updated tooling support helps drive developer productivity.  With Java 14, we continue to welcome the efforts of leading IDE vendors whose tooling solutions offer developers support for current Java versions.  Developers can expect to receive Java 14 support with the following IDEs:

  1. JetBrains IDEA
  2. Apache NetBeans
  3. Eclipse IDE

Popular build automation tools used primarily for Java projects are also prepared to offer Java 14 support to developers.  Both Apache Maven and its plug-ins as well as the Gradle 6.3 release candidate support Java 14.

Java continues to be the #1 programming language of choice by software programmers.  As the on-time delivery of improvements with Java 14 demonstrates, through continued thoughtful planning and ecosystem involvement, the Java platform is well-positioned for modern development and growth in the cloud.

Join the discussion

Comments ( 2 )
  • iPradeepan Tuesday, March 17, 2020
    Thank you for sharing this information with us!. Great!
  • Bruno Souza Wednesday, March 18, 2020
    Congrats to everyone involved for one more amazing release!

    The 6 months release cadence is by far the most important change that happened for Java.

Please enter your name.Please provide a valid email address.Please enter a comment.CAPTCHA challenge response provided was incorrect. Please try again.