Java 15 Is Now Available

Follow OpenJDK on Twitter

In 2020, we celebrate 25 years of Java. Over those years, Java has given users over two decades of innovation built on the momentum of previous enhancements such as Generics in Java 5, Lambdas in Java 8 and Modules in Java 9, which collectively culminate in boosting performance, stability and security of the Java platform along the way.

And further demonstrating Java’s path of continued innovation, Oracle is proud to announce the general availability of Java 15 for all developers and enterprises, which represents the sixth feature release as part of the six-month cadence. For over two years, this level of predictability allows developers to more easily manage their adoption of innovation thanks to a steady stream of incremental and expected changes.

Java 15 is now available

Oracle provides two binary releases of Java 15:

• Oracle OpenJDK 15 is released under the open source GNU General Public License v2, with the Classpath Exception (GPLv2+CPE).
• Oracle JDK 15 is released under a commercial license for those who want commercial support or are using the Oracle JDK as part of an Oracle product or service.

Oracle JDK 15 will receive a minimum of two quarterly update, per the Oracle Critical Patch Update (CPU) schedule, before being followed by Oracle JDK 16. Java 16 will reach general availability in March 2021, and early access builds of Oracle OpenJDK 16 are already being offered at jdk.java.net.

Java 15, Together

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

JDK 15 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, as well as 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 2,136 JIRA issues marked as fixed in Java 15, 1,702 were completed by people working for Oracle, while 434 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 Java 15:

Oracle would like to thank the developers working for organizations like ARM, Amazon, IBM, Intel, NTT Data, Red Hat, SAP and Tencent for their notable contributions. We are also thankful to see contributions from smaller organizations such as Ampere Computing, Bellsoft, Longsoon, and independent developers who collectively contributed 3% of the fixes in Java 15. And, last but not least, we’d like to acknowledge the first contributions from DataDog and Microsoft.

We would also like to recognize 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 who provided useful feedback on build quality, logged quality bugs or offered frequent updates:

• Uwe Schindler (representing Apache Lucene)
• Xeno Amess (representing Apache Maven)
• Tilman Hausherr (representing Apache PDFBox)
• Mark Thomas (representing Apache Tomcat)
• Raphael Winterhalter (representing Byte Buddy)
• Simone Bordet (representing Eclipse Jetty)
• Peter Karich (representing Graphhopper)
• Marc Hoffmann (representing JaCoCo)
• Vincent Privat (representing JOSM)
• Christian Stein (representing JUnit)
• Norman Maurer (representing Netty)

New in Java 15

Java 15 offers users fourteen main enhancements/changes, including one incubator module, 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, allowing them to offer feedback that can ultimately improve the quality of the Java platform.

Similarly, some enhancements are introduced as Preview features, which are 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 developers the chance to provide timely feedback, as well as allows 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. Deprecation encourages applications to migrate away from the API, discourages applications from forming new dependencies on the API, and informs 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 14 JEPs delivered with Java 15 are identifiable across four different categories:

New Features

JEP 339 Edwards-Curve Digital Signature Algorithm

This feature improves security and performance by implementing cryptographic signatures using the Edwards-Curve Digital Signature Algorithm (EdDSA) as described by RFC 8032. EdDSA is a modern elliptic curve signature scheme that has several advantages over the existing signature schemes in the JDK. The primary goal of this JEP is an implementation of this scheme as standardized in RFC 8032. This new signature scheme does not replace ECDSA.

JEP 371 Hidden Classes

This feature assists frameworks that need to generate classes at run time. Frameworks generate classes to dynamically extend their behavior, but it is desirable to limit access to those classes. Hidden classes are helpful because they can only be accessed via reflection, not from ordinary bytecode. In addition, hidden classes can be unloaded independently of other classes, which may reduce a framework's memory footprint.

Preview and Experimental Features that are now Finalized

JEP 377 ZGC: A Scalable Low-Latency GC

ZGC was integrated into JDK 11 by JEP 333, with the goal to improve productivity by reducing GC pause times, handle heaps ranging from relatively small (a few hundreds of megabytes) to very large (many terabytes) in size, as well as lay a foundation for future GC features and optimizations leveraging colored pointers and load barriers. With JEP 377, ZGC change from an experimental feature into a production feature.

JEP 378 Text Blocks

Text blocks were proposed by JEP 355 in 2019. A text block is a multi-line string literal that avoids the need for most escape sequences, automatically formats the string in a predictable way, and gives developers control over the format when desired. With JEP 378, Text Blocks become a permanent feature of the Java language.

JEP 379 Shenandoah

Shenandoah was integrated into JDK 12 by JEP 189. It was marked as experimental in order to match the status of other new GCs, notably Epsilon GC and ZGC. JEP 379 changes the Shenandoah garbage collector from an experimental feature into a product feature but does not propose to change the default GC, which continues to remain G1, and does not propose to change the Shenandoah development process, which will continue to support both the latest JDK and popular LTS/STS JDKs.

Incubating and Preview Features

JEP 360 Sealed Classes - first preview

This preview feature improves developer productivity by enhancing the Java programming with sealed classes and interfaces, which allows the author of a class or interface to control which code is responsible for implementing it, provides a more declarative way than access modifiers to restrict the use of a superclass and support future directions in pattern matching by underpinning the exhaustive analysis of patterns.

JEP 375 Pattern Matching for instanceof - second preview

This preview feature, which was first introduced in JEP 305 as part of JDK 14, improves developer productivity by eliminating the need for common boilerplate code and should allow more concise type safe code.

JEP 384 Records - second preview

Records improves developer productivity by providing a compact syntax for declaring classes which act as transparent carriers for immutable data. Records were proposed by JEP 359 in mid 2019 and delivered as a preview feature in JDK 14. This JEP proposes to re-preview the feature in JDK 15, both to incorporate refinements based on feedback and to support additional forms of local classes and interfaces in the Java language.

JEP 383 Foreign-Memory Access API - second incubator

The Foreign-Memory Access API was proposed by JEP 370 and targeted to JDK 14 in late 2019 as an incubating API. This JEP proposes to incorporate refinements based on feedback and re-incubate the API in JDK 15. This incubating feature defines an API to allow Java programs to safely and efficiently access foreign memory outside of the Java heap.

Modernizing the JDK

The JDK has thousands of features implemented by millions of lines of code, and it's important to preserve the reliability and maintainability of that code. Features that are outdated or that see very little use may have their code removed, while other features may have their code rewritten for stability and performance. Features are never removed without being deprecated for at least one release first. JDK 15 deprecates two features, and removes two other features that were previously deprecated. JDK 15 also modernizes the implementation of the networking stack.

JEP 374 Disable and deprecate biased locking

JEP 374 disables biased locking by default and deprecate all related command-line options.

JEP 385 Deprecate RMI Activation for Removal

JEP 385 Deprecates the RMI Activation mechanism for future removal. RMI Activation is an obsolete part of RMI that has been optional since Java 8. No other part of RMI will be deprecated.

JEP 372 Remove the Nashorn JavaScript Engine

JEP 372 removes the Nashorn JavaScript script engine and APIs, and the jjs tool. The engine, the APIs, and the tool were deprecated for removal in JDK 11 with the express intent to remove them in a future release.

JEP 381 Remove the Solaris and SPARC Ports

JEP 381 removes the source code and build support for the Solaris/SPARC, Solaris/x64, and Linux/SPARC ports. These ports were deprecated for removal in JDK 14 with the express intent to remove them in a future release.

JEP 373 Reimplement the legacy Datagram Socket API

This feature improves the maintainability and stability of the JDK by replacing the underlying implementations of the java.net.DatagramSocket and java.net.MulticastSocket APIs with simpler and more modern implementations. The new implementations will be easy to adapt to work with virtual threads, currently being explored in Project Loom. This is a follow-on to JEP 353, which already reimplemented the legacy Socket API.

Tooling Support

Current tooling support helps drive developer productivity. With Java 15, 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 15 support with the following IDEs:

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

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